public static XElement XslIf(this XElement element, XPathExpr test) { XElement valueOfElement = element.XslGenericElement("if"); valueOfElement.AddAttributeWithValue("test", test); return(valueOfElement); }
public XPathExpr GetGroupMembers(PSMComponent component, bool useCurrentInstanceVariable) { List <PSMComponent> groupMembers = new List <PSMComponent>(); AddGroupMembersRecursive(component, ref groupMembers); List <XPathExpr> result = new List <XPathExpr>(); foreach (PSMComponent psmComponent in groupMembers) { if (!psmComponent.ExistsInVersion(this.OldVersion)) { continue; } result.Add(this.GetRelativeXPath(psmComponent, useCurrentInstanceVariable)); } if (result.Count == 0) { return(new XPathExpr("()")); } else { return(XPathExpr.ConcatWithPipeOperator(result)); } }
public static XElement XslFunction(this XElement element, string name, string @as, params TemplateParameter[] parameters) { XElement templateElement = element.XslGenericElement("function"); templateElement.AddAttributeWithValue("name", name); if (!string.IsNullOrEmpty(@as)) { templateElement.AddAttributeWithValue("as", @as); } if (parameters != null) { foreach (TemplateParameter parameter in parameters) { XElement param = templateElement.XslGenericElement("param"); param.AddAttributeWithValue("name", parameter.Name); if (!string.IsNullOrEmpty(parameter.Type)) { param.AddAttributeWithValue("as", parameter.Type); } if (!XPathExpr.IsNullOrEmpty(parameter.DefaultValue)) { param.AddAttributeWithValue("select", parameter.DefaultValue); } } } return(templateElement); }
public static XElement XslSequence(this XElement element, XPathExpr selectXPath) { XElement valueOfElement = element.XslGenericElement("sequence"); valueOfElement.AddAttributeWithValue("select", selectXPath); return(valueOfElement); }
public static XElement XslForEachGroup(this XElement element, XPathExpr selectXPath) { XElement copyOfElement = element.XslGenericElement("for-each-group"); copyOfElement.AddAttributeWithValue("select", selectXPath); return(copyOfElement); }
public static XElement XslForEach(this XElement element, XPathExpr selectXPath) { XElement forEachElement = element.XslGenericElement("for-each"); forEachElement.AddAttributeWithValue("select", selectXPath); return(forEachElement); }
public static XElement XslCopyOf(this XElement element, XPathExpr selectXPath) { XElement copyOfElement = element.XslGenericElement("copy-of"); copyOfElement.AddAttributeWithValue("select", selectXPath); return(copyOfElement); }
public static XElement XslWhen(this XElement element, XPathExpr test) { XElement option = element.XslGenericElement("when"); option.AddAttributeWithValue("test", test); return(option); }
public bool HasPrefix(XPathExpr prefix) { if (prefix == null) { throw new ArgumentNullException("prefix"); } return(this.ToString().StartsWith(prefix)); }
//public XPathExpr NoCurrentGroup() //{ // return new XPathExpr(this._expr.Replace("/" + CurrentInstanceVariableExpr, String.Empty)); //} #region equality members public bool Equals(XPathExpr other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(Equals(other._expr, _expr)); }
public static XElement XslTemplate(this XElement element, XPathExpr matchXPath, params string[] parameters) { XElement templateElement = element.XslGenericElement("template"); templateElement.AddAttributeWithValue("match", matchXPath); if (parameters != null) { foreach (string parameter in parameters) { XElement param = templateElement.XslGenericElement("param"); param.AddAttributeWithValue("name", parameter); } } return(templateElement); }
public static XElement XslVariable(this XElement element, string name, XPathExpr selectXPath = null, string type = null) { XElement variableElement = element.XslGenericElement("variable"); variableElement.AddAttributeWithValue("name", name); if (selectXPath != null) { variableElement.AddAttributeWithValue("select", selectXPath); } if (!string.IsNullOrEmpty(type)) { variableElement.AddAttributeWithValue("as", type); } return(variableElement); }
private static XElement XslApplyTemplates(this XElement element, XPathExpr selectXPath, IEnumerable <TemplateParameter> parameters) { XElement applyTemplatesElement = element.XslGenericElement("apply-templates"); applyTemplatesElement.AddAttributeWithValue("select", selectXPath); if (parameters != null) { foreach (TemplateParameter keyValuePair in parameters) { XElement param = applyTemplatesElement.XslGenericElement("with-param"); param.AddAttributeWithValue("name", keyValuePair.Name); param.AddAttributeWithValue("select", keyValuePair.Value); } } return(applyTemplatesElement); }
public XPathExpr GetRelativeXPath(IEnumerable <PSMComponent> expandedReference, bool useCurrentInstanceVariable) { IEnumerable <XPathExpr> result = from component in expandedReference select GetRelativeXPath(component, useCurrentInstanceVariable); return(XPathExpr.ConcatWithPipeOperator(result)); }
public XPathExpr GetGroupDistinguisher(IEnumerable <PSMComponent> expandedReference) { IEnumerable <XPathExpr> result = from component in expandedReference select GetGroupDistinguisher(component); return(XPathExpr.ConcatWithPipeOperator(result)); }
/* * useCurrentInstanceVariable is probably always false in the current version of the algorithm. */ public XPathExpr GetRelativeXPath(PSMComponent node, bool useCurrentInstanceVariable, string currentInstanceVariableName = XDocumentXsltExtensions.ParamCurrentInstance) { PSMComponent closestExistingCurrentNode = CurrentNode.GetFirstAncestorOrSelfExistingInVersion(OldVersion).GetInVersion(OldVersion); PSMComponent closestExistingTargetNode = node.GetFirstAncestorOrSelfExistingInVersion(OldVersion).GetInVersion(OldVersion); if (closestExistingTargetNode == null) { throw new InvalidOperationException(); } if (closestExistingCurrentNode == null) { return(new XPathExpr(closestExistingTargetNode.XPath)); } XPathExpr currentNodeAbsoluteXPath = new XPathExpr(closestExistingCurrentNode.GetInVersion(OldVersion).XPath); // /A/R XPathExpr targetNodeAbsoluteXPath = new XPathExpr(closestExistingTargetNode.GetInVersion(OldVersion).XPath); // /A/R/B/z if (targetNodeAbsoluteXPath.HasPrefix(currentNodeAbsoluteXPath) && targetNodeAbsoluteXPath != currentNodeAbsoluteXPath) { string withoutPrefix = targetNodeAbsoluteXPath.ToString().Substring(currentNodeAbsoluteXPath.ToString().Length); while (withoutPrefix[0].IsAmong('/', '@')) { withoutPrefix = withoutPrefix.Substring(1); } string nextStep; if (withoutPrefix.IndexOf('/') == -1) { nextStep = withoutPrefix.Substring(0, withoutPrefix.Length); } else { nextStep = withoutPrefix.Substring(0, withoutPrefix.IndexOf('/')); } string afterNextStep = withoutPrefix.Substring(nextStep.Length); XPathExpr result; if (useCurrentInstanceVariable) { result = new XPathExpr(string.Format("${3}[name() = '{0}']{1}{2}", nextStep, string.IsNullOrEmpty(afterNextStep) ? string.Empty : "/", afterNextStep, currentInstanceVariableName)); } else { result = new XPathExpr(string.Format("{0}{1}{2}", nextStep, string.IsNullOrEmpty(afterNextStep) ? string.Empty : "/", afterNextStep)); } return(result); } else if (targetNodeAbsoluteXPath == currentNodeAbsoluteXPath) { return(new XPathExpr(".")); } else { // find the uppermost common node PSMAssociationMember nearestCommonAncestor = closestExistingCurrentNode.GetNearestCommonAncestor(closestExistingTargetNode); if (nearestCommonAncestor != null) { string commonPath = nearestCommonAncestor.XPath; Debug.Assert(targetNodeAbsoluteXPath.HasPrefix(new XPathExpr(commonPath))); Debug.Assert(currentNodeAbsoluteXPath.HasPrefix(new XPathExpr(commonPath))); string fromCommonToTarget = targetNodeAbsoluteXPath.ToString().Replace(commonPath, string.Empty); string fromCommonToCurrent = currentNodeAbsoluteXPath.ToString().Replace(commonPath, string.Empty); string stepsUp = string.Empty; foreach (char c in fromCommonToCurrent) { if (c == '/') { stepsUp += "../"; } } if (fromCommonToTarget.StartsWith("/")) { fromCommonToTarget = fromCommonToTarget.Substring(1); } string joined = string.Format("{0}{1}", stepsUp, fromCommonToTarget); if (joined.EndsWith("/")) { joined = joined.Substring(0, joined.Length - 1); } return(new XPathExpr(joined)); } else { return(new XPathExpr(closestExistingTargetNode.XPath)); } } }
public static TemplateParameter CreateCurrentInstanceParameterCall(XPathExpr select) { return(new TemplateParameter(ParamCurrentInstance, select)); }
public XPathExpr(XPathExpr expression) { _expr = expression._expr; }
public TemplateParameter(string name, XPathExpr value) : this() { Name = name; Value = value; }
public static bool IsNullOrEmpty(XPathExpr expr) { return(expr == null || expr.IsEmpty()); }
public static XElement XslApplyTemplates(this XElement element, XPathExpr selectXPath, params TemplateParameter[] parameters) { return(XslApplyTemplates(element, selectXPath, (IEnumerable <TemplateParameter>)parameters)); }