public bool HasPrefix(XPathExpr prefix)
{
if (prefix == null)
{
throw new ArgumentNullException("prefix");
}
return(this.ToString().StartsWith(prefix));
}
/// <summary>
/// Converts path <paramref name="oldPath"/>
/// into a path relative to <paramref name="context"/>.<see cref="XsltGeneratorContext.ProcessedPath"/>.
/// (and also relative to <paramref name="context"/>.<see cref="XsltGeneratorContext.ContentGroupPath"/> if it is used).
/// </summary>
/// <param name="context">current generator context</param>
/// <param name="oldPath">projected path</param>
/// <returns>relative xpath expression</returns>
public static XPathExpr GroupAwareProjectXPathWithoutAttributeCorrection(XsltGeneratorContext context, XPathExpr oldPath)
{
if (context.InGroup && oldPath.HasPrefix(context.ContentGroupPath))
{
oldPath = oldPath.InsertAfterPrefix(context.ContentGroupPath, "/$cg");
}
XPathExpr tmp = ProjectXPath(context.ProcessedPath, oldPath, context.InGroup);
return(tmp);
}
public bool Equals(XPathExpr other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Equals(other._expr, _expr));
}
internal XPathExpr NodeToProcessedPath(PSMElement node)
{
Version oldVersion = ChangeSet.OldVersion;
if (!InGroup)
{
return(XPathHelper.GetXPathForNode(node, oldVersion));
}
else
{
XPathExpr path = XPathHelper.GetXPathForNode(node, oldVersion).Append("/$cg");
//if (InGroup/* && ProcessedPath.HasPrefix(ContentGroupPath)*/)
{
Debug.Assert(path.HasPrefix(ContentGroupPath));
Debug.Assert(path == (!ContentGroupPath.ToString().EndsWith("/$cg") ? ContentGroupPath.Append("/$cg") : ContentGroupPath));
//path = path.InsertAfterPrefix(ContentGroupPath, "/$cg");
}
return(path);
}
}
/// <summary>
/// Adds '[1]' predicate to each step (thus the xpath expression only selects the first child in each step).
/// </summary>
/// <param name="xpath">xpath</param>
/// <param name="leaveLastStep">if set to <c>true</c> leaves the last step intact.</param>
/// <returns></returns>
public static XPathExpr AllwaysReferenceFirstChild(XPathExpr xpath, bool leaveLastStep)
{
string tmp = xpath.ToString();
System.Text.RegularExpressions.Regex r =
new System.Text.RegularExpressions.Regex("/");
tmp = tmp.Replace("$cg/", "__CG__");
string tmp2 = r.Replace(tmp, "[1]/", int.MaxValue, 1);
tmp2 = tmp2.Replace("__CG__", "$cg/");
int p = tmp2.LastIndexOf("/");
if (!leaveLastStep && !tmp2.EndsWith("/") && tmp2[p + 1] != '@' && tmp2[p + 1] != '[')
{
tmp2 = tmp2 + "[1]";
}
//!tmp2.StartsWith("/") && !tmp2.StartsWith("@") && !tmp2.EndsWith(XPathExpr.CurrentGroupVariableExpr))
//tmp2 = tmp2.Insert(tmp.Contains("/") ? tmp2.IndexOf("/") : tmp2.Length, "[1]");
return(new XPathExpr(tmp2));
}
/// <summary>
/// Converts path to <paramref name="psmElementNewVersion"/>
/// into a path relative to <paramref name="context"/>.<see cref="XsltGeneratorContext.ProcessedPath"/>.
/// (and also relative to <paramref name="context"/>.<see cref="XsltGeneratorContext.ContentGroupPath"/> if it is used).
/// If context is in group (<see cref="XsltGeneratorContext"/>.<see cref="XsltGeneratorContext.InGroup"/>) which
/// has group attributes and <paramref name="psmElementNewVersion"/> is one of these attributes, the returned path
/// is modified to use the '$attributes' variable.
/// </summary>
/// <param name="context">current generator context</param>
/// <param name="psmElementNewVersion">element for which the path is projected</param>
/// <param name="oldVersion">old version, used to determine the path to <paramref name="psmElementNewVersion"/> in the
/// old version of the diagram</param>
/// <returns>relative xpath expression</returns>
public static XPathExpr GroupAwareProjectXPath(XsltGeneratorContext context, PSMElement psmElementNewVersion, Version oldVersion)
{
XPathExpr oldPath = ((PSMElement)psmElementNewVersion.GetInVersion(oldVersion)).XPathE();
if (context.InGroup && oldPath.HasPrefix(context.ContentGroupPath))
{
oldPath = oldPath.InsertAfterPrefix(context.ContentGroupPath, "/$cg");
}
XPathExpr tmp = ProjectXPath(context.ProcessedPath, oldPath, context.InGroup);
if (context.InGroup && context.ContentGroupAttributes != null && psmElementNewVersion is PSMAttribute &&
context.ContentGroupAttributes.Contains((PSMAttribute)psmElementNewVersion))
{
if (tmp.ToString().StartsWith(XPathExpr.CurrentGroupVariableExpr))
{
tmp = new XPathExpr(tmp.ToString().Replace(XPathExpr.CurrentGroupVariableExpr, "$attributes"));
}
}
return(tmp);
}
public static bool IsNullOrEmpty(XPathExpr expr)
{
return(expr == null || expr.IsEmpty());
}
public XPathExpr InsertAfterPrefix(XPathExpr prefix, string insertedExpr)
{
Debug.Assert(HasPrefix(prefix));
return(new XPathExpr(this.ToString().Insert(prefix.ToString().Length, insertedExpr)));
}
public static XPathExpr DummyUpStep(XPathExpr xPathExpr)
{
return(new XPathExpr("..{0}", xPathExpr._expr.Substring(xPathExpr._expr.LastIndexOf("/"))));
}
public XPathExpr(XPathExpr expression)
{
_expr = expression._expr;
}
//public enum EProjectionResultType
//{
// Ancestor,
// Descendant,
// Self,
// Absolute
//}
/// <summary>
/// Converts <paramref name="pathTo"/>
/// into a path relative to <paramref name="currentPath"/>.
/// </summary>
/// <param name="pathTo">projected path</param>
/// <param name="currentPath">currentPath</param>
/// <param name="inGroup">flag if current path can is group path</param>
/// <returns>relative xpath expression</returns>
private static XPathExpr ProjectXPath(XPathExpr currentPath, XPathExpr pathTo, bool inGroup)
{
//EProjectionResultType projectionType = EProjectionResultType.Absolute;
if (currentPath == null)
{
return(pathTo);
}
char[] separator = new[] { '/' };
string[] cn_parts = currentPath.ToString().Split(separator, StringSplitOptions.RemoveEmptyEntries);
string[] path_parts = pathTo.ToString().Split(separator, StringSplitOptions.RemoveEmptyEntries);
int countSame = 0;
while (cn_parts.Length > countSame && path_parts.Length > countSame && cn_parts[countSame] == path_parts[countSame])
{
countSame++;
}
string res = String.Empty;
bool cgHandled = false;
for (int j = countSame; j < path_parts.Length; j++)
{
// removed and replaced by variable construction
if (inGroup && !cgHandled && cn_parts[j - 1] == XPathExpr.CurrentGroupVariableExpr)
{
string name = path_parts[j];
// HACK: for attribute matching in groups @ is stripped from the name
name = name.TrimStart('@');
res += string.Format("$cg[name() = '{0}']", name);
//projectionType = EProjectionResultType.Descendant;
if (j < path_parts.Length - 1)
{
res += "/";
}
cgHandled = true;
}
else
{
res += path_parts[j];
//projectionType = EProjectionResultType.Descendant;
if (j < path_parts.Length - 1)
{
res += "/";
}
}
}
if (countSame > 0 && path_parts.Length == countSame)
{
//projectionType = EProjectionResultType.Self;
// up
for (int j = countSame; j < cn_parts.Length; j++)
{
res += "../";
}
// and down again
for (int j = countSame; j < cn_parts.Length; j++)
{
res += cn_parts[j];
if (j < cn_parts.Length - 1)
{
res += "/";
}
}
}
return(new XPathExpr(res));
}
/// <summary>
/// Performs <see cref="GroupAwareProjectXPath"/> and substitutes steps in the result path according
/// to structural representative information. (So the path is relative to the structural representative)
/// </summary>
/// <param name="context">The generator context.</param>
/// <param name="element">The element.</param>
/// <param name="structuralRepresentativeReplacement">The structural representative replacement.</param>
/// <returns></returns>
public static XPathExpr GroupAwareProjectXPathWithSRSubstitution(XsltGeneratorContext context, PSMElement element, IFromStructuralRepresentative structuralRepresentativeReplacement)
{
XPathExpr expr;
if (structuralRepresentativeReplacement != null)
{
var cp = context.ProcessedPath;
//if (PSMTreeIterator.AreInTheSamePSMTree(structuralRepresentativeReplacement.RepresentedPSMClass, structuralRepresentativeReplacement.StructuralRepresentative))
PSMElement representedOldAnc = PSMTreeIterator.GetSignificantAncestorOrSelf((PSMClass)structuralRepresentativeReplacement.RepresentedPSMClass.GetInVersion(context.ChangeSet.OldVersion));
PSMElement structuralRepresentativeOldAnc = PSMTreeIterator.GetSignificantAncestorOrSelf((PSMClass)structuralRepresentativeReplacement.StructuralRepresentative.GetInVersion(context.ChangeSet.OldVersion));
if (representedOldAnc != null)
{
context.ProcessedPath = GetXPathForNode(representedOldAnc, context.ChangeSet.OldVersion);
}
else
{
context.ProcessedPath = new XPathExpr("<virt-root>");
if (context.InGroup)
{
context.ProcessedPath = context.ProcessedPath.Append("/$cg");
}
}
string from = representedOldAnc != null?XsltTemplateNameManager.GetElementNameForSignificantElement(representedOldAnc) : null;
string to = structuralRepresentativeOldAnc != null?XsltTemplateNameManager.GetElementNameForSignificantElement(structuralRepresentativeOldAnc) : null;
XPathExpr e = null;
if (from != null && to != null &&
!(context.ProcessedPath.ToString().EndsWith(from) && cp.ToString().EndsWith(to)))
{
e = ProjectXPath(cp, context.ProcessedPath, false);
if (!XPathExpr.IsNullOrEmpty(e) && !String.IsNullOrEmpty(to) && !String.IsNullOrEmpty(from))
{
if (e.ToString().Contains(from))
{
e = new XPathExpr(e.ToString().Replace(from, to));
}
}
}
expr = GroupAwareProjectXPath(context, element, context.ChangeSet.OldVersion);
if (!XPathExpr.IsNullOrEmpty(e))
{
// ReSharper disable PossibleNullReferenceException
expr = e.Append("/" + expr);
}
// ReSharper restore PossibleNullReferenceException
context.ProcessedPath = cp;
}
else
{
expr = GroupAwareProjectXPath(context, element, context.ChangeSet.OldVersion);
}
return(expr);
}
