/// <summary> /// Gets the list of nodes or attributes below the position indicated /// </summary> /// <param name="rootNode">The root node for the xml data</param> /// <param name="currentParentNode">The current node</param> /// <param name="xmlDiffPathExpr">Proprietary path statement separator or character</param> /// <returns>List of nodes or attributes</returns> public static XmlDiffPathNodeList SelectNodes( XmlDiffViewParentNode rootNode, XmlDiffViewParentNode currentParentNode, string xmlDiffPathExpr) { switch (xmlDiffPathExpr[0]) { case '/': return SelectAbsoluteNodes(rootNode, xmlDiffPathExpr); case '@': if (xmlDiffPathExpr.Length < 2) { OnInvalidExpression(xmlDiffPathExpr); } if (xmlDiffPathExpr[1] == '*') { return SelectAllAttributes( (XmlDiffViewElement)currentParentNode); } else { return SelectAttributes( (XmlDiffViewElement)currentParentNode, xmlDiffPathExpr); } case '*': if (xmlDiffPathExpr.Length == 1) { return SelectAllChildren(currentParentNode); } else { OnInvalidExpression(xmlDiffPathExpr); return null; } default: int startPosition = 0; return SelectChildNodes( currentParentNode, xmlDiffPathExpr, startPosition); } }
internal static XmlDiffPathNodeList SelectNodes( XmlDiffViewParentNode rootNode, XmlDiffViewParentNode currentParentNode, string xmlDiffPathExpr ) { switch ( xmlDiffPathExpr[0] ) { case '/': return SelectAbsoluteNodes( rootNode, xmlDiffPathExpr ); case '@': if ( xmlDiffPathExpr.Length < 2 ) OnInvalidExpression( xmlDiffPathExpr ); if ( xmlDiffPathExpr[1] == '*' ) return SelectAllAttributes( (XmlDiffViewElement)currentParentNode ); else return SelectAttributes( (XmlDiffViewElement)currentParentNode, xmlDiffPathExpr ); case '*': if ( xmlDiffPathExpr.Length == 1 ) return SelectAllChildren( currentParentNode ); else { OnInvalidExpression( xmlDiffPathExpr ); return null; } default: return SelectChildNodes( currentParentNode, xmlDiffPathExpr, 0 ); } }
static XmlDiffPathNodeList SelectAllChildren(XmlDiffViewParentNode parentNode) { if (parentNode._childNodes == null) { OnNoMatchingNode("*"); return(null); } else if (parentNode._childNodes._nextSibbling == null) { XmlDiffPathNodeList nodeList = new XmlDiffPathSingleNodeList(); nodeList.AddNode(parentNode._childNodes); return(nodeList); } else { XmlDiffPathNodeList nodeList = new XmlDiffPathMultiNodeList(); XmlDiffViewNode childNode = parentNode._childNodes; while (childNode != null) { nodeList.AddNode(childNode); childNode = childNode._nextSibbling; } return(nodeList); } }
internal static XmlDiffPathNodeList SelectNodes( XmlDiffViewParentNode rootNode, XmlDiffViewParentNode currentParentNode, string xmlDiffPathExpr) { switch (xmlDiffPathExpr[0]) { case '*': if (xmlDiffPathExpr.Length == 1) { return(XmlDiffPath.SelectAllChildren(currentParentNode)); } XmlDiffPath.OnInvalidExpression(xmlDiffPathExpr); return((XmlDiffPathNodeList)null); case '/': return(XmlDiffPath.SelectAbsoluteNodes(rootNode, xmlDiffPathExpr)); case '@': if (xmlDiffPathExpr.Length < 2) { XmlDiffPath.OnInvalidExpression(xmlDiffPathExpr); } return(xmlDiffPathExpr[1] == '*' ? XmlDiffPath.SelectAllAttributes((XmlDiffViewElement)currentParentNode) : XmlDiffPath.SelectAttributes((XmlDiffViewElement)currentParentNode, xmlDiffPathExpr)); default: return(XmlDiffPath.SelectChildNodes(currentParentNode, xmlDiffPathExpr, 0)); } }
/// <summary> /// Gets a list of node objects corresponding to /// the proprietary path reference provided. /// </summary> /// <param name="rootNode">The starting node</param> /// <param name="path">Absolute path reference to node of interest</param> /// <returns>list of node objects</returns> private static XmlDiffPathNodeList SelectAbsoluteNodes( XmlDiffViewParentNode rootNode, string path) { Debug.Assert(path[0] == '/'); int pos = 1; XmlDiffViewNode node = rootNode; for (; ;) { int startPos = pos; int nodePos = ReadPosition(path, ref pos); if (pos == path.Length || path[pos] == '/') { if (node.FirstChildNode == null) { OnNoMatchingNode(path); } XmlDiffViewParentNode parentNode = (XmlDiffViewParentNode)node; if (nodePos <= 0 || nodePos > parentNode. SourceChildNodesCount) { OnNoMatchingNode(path); } node = parentNode.GetSourceChildNode(nodePos - 1); if (pos == path.Length) { XmlDiffPathNodeList list = new XmlDiffPathSingleNodeList(); list.AddNode(node); return(list); } pos++; } else { if (path[pos] == '-' || path[pos] == '|') { if (node.FirstChildNode == null) { OnNoMatchingNode(path); } return(SelectChildNodes( ((XmlDiffViewParentNode)node), path, startPos)); } OnInvalidExpression(path); } } }
private void OnRemove(XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { // opid & descriptor XmlDiffViewOperation op = XmlDiffViewOperation.Remove; int opid = 0; OperationDescriptor opDesc = null; string opidAttr = diffgramElement.GetAttribute("opid"); if (opidAttr != string.Empty) { opid = int.Parse(opidAttr); opDesc = GetDescriptor(opid); if (opDesc._type == OperationDescriptor.Type.Move) { op = XmlDiffViewOperation.MoveFrom; } } // subtree string subtreeAttr = diffgramElement.GetAttribute("subtree"); bool bSubtree = (subtreeAttr != "no"); if (!bSubtree) { if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'remove' element must select a single node when the 'subtree' attribute is specified."); } // annotate node matchNodes.MoveNext(); XmlDiffViewNode node = matchNodes.Current; AnnotateNode(node, op, opid, false); if (opid != 0) { opDesc._nodeList.AddNode(node); } // recurse ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)node); } else { // annotate nodes matchNodes.Reset(); while (matchNodes.MoveNext()) { if (opid != 0) { opDesc._nodeList.AddNode(matchNodes.Current); } AnnotateNode(matchNodes.Current, op, opid, true); } } }
private static XmlDiffPathNodeList SelectAbsoluteNodes( XmlDiffViewParentNode rootNode, string path) { Debug.Assert(path[0] == '/'); var pos = 1; var node = (XmlDiffViewNode)rootNode; int startPos; while (true) { startPos = pos; var num = XmlDiffPath.ReadPosition(path, ref pos); if (pos == path.Length || path[pos] == '/') { if (node.FirstChildNode == null) { XmlDiffPath.OnNoMatchingNode(path); } var diffViewParentNode = (XmlDiffViewParentNode)node; if (num <= 0 || num > diffViewParentNode._sourceChildNodesCount) { XmlDiffPath.OnNoMatchingNode(path); } node = diffViewParentNode.GetSourceChildNode(num - 1); if (pos != path.Length) { ++pos; } else { break; } } else if (path[pos] != '-' && path[pos] != '|') { XmlDiffPath.OnInvalidExpression(path); } else { goto label_10; } } var diffPathNodeList = (XmlDiffPathNodeList) new XmlDiffPathSingleNodeList(); diffPathNodeList.AddNode(node); return(diffPathNodeList); label_10: if (node.FirstChildNode == null) { XmlDiffPath.OnNoMatchingNode(path); } return(XmlDiffPath.SelectChildNodes((XmlDiffViewParentNode)node, path, startPos)); }
private void OnAddFragment( XmlElement diffgramElement, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { foreach (XmlNode childNode in diffgramElement.ChildNodes) { var xmlDiffViewNode = this.ImportNode(childNode); sourceParent.InsertChildAfter(xmlDiffViewNode, currentPosition, false); currentPosition = xmlDiffViewNode; this.AnnotateNode(xmlDiffViewNode, XmlDiffViewOperation.Add, 0, true); } }
private void OnAddFragment(XmlElement diffgramElement, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { IEnumerator childNodes = diffgramElement.ChildNodes.GetEnumerator(); while (childNodes.MoveNext()) { XmlDiffViewNode newChildNode = ImportNode((XmlNode)childNodes.Current); sourceParent.InsertChildAfter(newChildNode, currentPosition, false); currentPosition = newChildNode; AnnotateNode(newChildNode, XmlDiffViewOperation.Add, 0, true); } }
private void OnRemove( XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { var op = XmlDiffViewOperation.Remove; var opid = 0; OperationDescriptor operationDescriptor = null; var attribute = diffgramElement.GetAttribute("opid"); if (attribute != string.Empty) { opid = int.Parse(attribute); operationDescriptor = this.GetDescriptor(opid); if (operationDescriptor._type == OperationDescriptor.Type.Move) { op = XmlDiffViewOperation.MoveFrom; } } if (!(diffgramElement.GetAttribute("subtree") != "no")) { if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'remove' element must select a single node when the 'subtree' attribute is specified."); } matchNodes.MoveNext(); var current = matchNodes.Current; this.AnnotateNode(current, op, opid, false); if (opid != 0) { operationDescriptor._nodeList.AddNode(current); } this.ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)current); } else { matchNodes.Reset(); while (matchNodes.MoveNext()) { if (opid != 0) { operationDescriptor._nodeList.AddNode(matchNodes.Current); } this.AnnotateNode(matchNodes.Current, op, opid, true); } } }
/// <summary> /// Gets the list of nodes or attributes below the position indicated /// </summary> /// <param name="rootNode">The root node for the xml data</param> /// <param name="currentParentNode">The current node</param> /// <param name="xmlDiffPathExpr">Proprietary path statement separator or character</param> /// <returns>List of nodes or attributes</returns> public static XmlDiffPathNodeList SelectNodes( XmlDiffViewParentNode rootNode, XmlDiffViewParentNode currentParentNode, string xmlDiffPathExpr) { switch (xmlDiffPathExpr[0]) { case '/': return(SelectAbsoluteNodes(rootNode, xmlDiffPathExpr)); case '@': if (xmlDiffPathExpr.Length < 2) { OnInvalidExpression(xmlDiffPathExpr); } if (xmlDiffPathExpr[1] == '*') { return(SelectAllAttributes( (XmlDiffViewElement)currentParentNode)); } else { return(SelectAttributes( (XmlDiffViewElement)currentParentNode, xmlDiffPathExpr)); } case '*': if (xmlDiffPathExpr.Length == 1) { return(SelectAllChildren(currentParentNode)); } else { OnInvalidExpression(xmlDiffPathExpr); return(null); } default: int startPosition = 0; return(SelectChildNodes( currentParentNode, xmlDiffPathExpr, startPosition)); } }
private void OnAddMatch( XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { var attribute = diffgramElement.GetAttribute("opid"); if (attribute == string.Empty) { throw new Exception("Missing opid attribute."); } var opid = int.Parse(attribute); var descriptor = this.GetDescriptor(opid); if (!(diffgramElement.GetAttribute("subtree") != "no")) { if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'add' element must select a single node when the 'subtree' attribute is specified."); } matchNodes.MoveNext(); var xmlDiffViewNode = matchNodes.Current.Clone(false); this.AnnotateNode(xmlDiffViewNode, XmlDiffViewOperation.MoveTo, opid, true); descriptor._nodeList.AddNode(xmlDiffViewNode); sourceParent.InsertChildAfter(xmlDiffViewNode, currentPosition, false); currentPosition = xmlDiffViewNode; this.ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)xmlDiffViewNode); } else { matchNodes.Reset(); while (matchNodes.MoveNext()) { var xmlDiffViewNode = matchNodes.Current.Clone(true); this.AnnotateNode(xmlDiffViewNode, XmlDiffViewOperation.MoveTo, opid, true); descriptor._nodeList.AddNode(xmlDiffViewNode); sourceParent.InsertChildAfter(xmlDiffViewNode, currentPosition, false); currentPosition = xmlDiffViewNode; } } }
private static XmlDiffPathNodeList SelectAllChildren( XmlDiffViewParentNode parentNode) { if (parentNode._childNodes == null) { XmlDiffPath.OnNoMatchingNode("*"); return((XmlDiffPathNodeList)null); } if (parentNode._childNodes._nextSibbling == null) { var diffPathNodeList = (XmlDiffPathNodeList) new XmlDiffPathSingleNodeList(); diffPathNodeList.AddNode(parentNode._childNodes); return(diffPathNodeList); } var diffPathNodeList1 = (XmlDiffPathNodeList) new XmlDiffPathMultiNodeList(); for (var node = parentNode._childNodes; node != null; node = node._nextSibbling) { diffPathNodeList1.AddNode(node); } return(diffPathNodeList1); }
static XmlDiffPathNodeList SelectChildNodes(XmlDiffViewParentNode parentNode, string path, int startPos) { int pos = startPos; XmlDiffPathNodeList nodeList = null; for (;;) { int nodePos = ReadPosition(path, ref pos); if (pos == path.Length) { nodeList = new XmlDiffPathSingleNodeList(); } else { nodeList = new XmlDiffPathMultiNodeList(); } if (nodePos <= 0 || nodePos > parentNode._sourceChildNodesCount) { OnNoMatchingNode(path); } nodeList.AddNode(parentNode.GetSourceChildNode(nodePos - 1)); if (pos == path.Length) { break; } else if (path[pos] == '|') { pos++; } else if (path[pos] == '-') { pos++; int endNodePos = ReadPosition(path, ref pos); if (endNodePos <= 0 || endNodePos > parentNode._sourceChildNodesCount) { OnNoMatchingNode(path); } while (nodePos < endNodePos) { nodePos++; nodeList.AddNode(parentNode.GetSourceChildNode(nodePos - 1)); } if (pos == path.Length) { break; } else if (path[pos] == '|') { pos++; } else { OnInvalidExpression(path); } } } return(nodeList); }
private void OnAddNode(XmlElement diffgramElement, string nodeTypeAttr, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { XmlNodeType nodeType = (XmlNodeType)int.Parse(nodeTypeAttr); string name = diffgramElement.GetAttribute("name"); string prefix = diffgramElement.GetAttribute("prefix"); string ns = diffgramElement.GetAttribute("ns"); string opidAttr = diffgramElement.GetAttribute("opid"); int opid = (opidAttr == string.Empty) ? 0 : int.Parse(opidAttr); if (nodeType == XmlNodeType.Attribute) { Debug.Assert(name != string.Empty); XmlDiffViewAttribute newAttr = new XmlDiffViewAttribute(name, prefix, ns, diffgramElement.InnerText); newAttr._op = XmlDiffViewOperation.Add; newAttr._opid = opid; ((XmlDiffViewElement)sourceParent).InsertAttributeAfter(newAttr, null); } else { XmlDiffViewNode newNode = null; switch (nodeType) { case XmlNodeType.Element: Debug.Assert(name != string.Empty); newNode = new XmlDiffViewElement(name, prefix, ns, _bIgnorePrefixes); ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)newNode); break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: Debug.Assert(diffgramElement.InnerText != string.Empty); newNode = new XmlDiffViewCharData(diffgramElement.InnerText, nodeType); break; case XmlNodeType.ProcessingInstruction: Debug.Assert(diffgramElement.InnerText != string.Empty); Debug.Assert(name != string.Empty); newNode = new XmlDiffViewPI(name, diffgramElement.InnerText); break; case XmlNodeType.EntityReference: Debug.Assert(name != string.Empty); newNode = new XmlDiffViewER(name); break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.InnerText != string.Empty); newNode = new XmlDiffViewXmlDeclaration(diffgramElement.InnerText); break; case XmlNodeType.DocumentType: newNode = new XmlDiffViewDocumentType(diffgramElement.GetAttribute("name"), diffgramElement.GetAttribute("publicId"), diffgramElement.GetAttribute("systemId"), diffgramElement.InnerText); break; default: Debug.Assert(false, "Invalid node type."); break; } Debug.Assert(newNode != null); newNode._op = XmlDiffViewOperation.Add; newNode._opid = opid; sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; } }
private void OnAddMatch(XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { string opidAttr = diffgramElement.GetAttribute("opid"); if (opidAttr == string.Empty) { throw new Exception("Missing opid attribute."); } // opid & descriptor int opid = int.Parse(opidAttr); OperationDescriptor opDesc = GetDescriptor(opid); string subtreeAttr = diffgramElement.GetAttribute("subtree"); bool bSubtree = (subtreeAttr != "no"); // move single node without subtree if (!bSubtree) { if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'add' element must select a single node when the 'subtree' attribute is specified."); } // clone node matchNodes.MoveNext(); XmlDiffViewNode newNode = matchNodes.Current.Clone(false); AnnotateNode(newNode, XmlDiffViewOperation.MoveTo, opid, true); opDesc._nodeList.AddNode(newNode); // insert in tree sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; // recurse ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)newNode); } // move subtree else { matchNodes.Reset(); while (matchNodes.MoveNext()) { XmlDiffViewNode newNode = matchNodes.Current.Clone(true); AnnotateNode(newNode, XmlDiffViewOperation.MoveTo, opid, true); opDesc._nodeList.AddNode(newNode); sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; } } }
/// <summary> /// Gets a list of all node objects at and below the location /// specified. /// </summary> /// <param name="parentNode">Node at which to start</param> /// <returns>list of node objects</returns> private static XmlDiffPathNodeList SelectAllChildren( XmlDiffViewParentNode parentNode) { if (parentNode.ChildNodes == null) { OnNoMatchingNode("*"); return null; } else if (parentNode.ChildNodes.NextSibbling == null) { XmlDiffPathNodeList nodeList = new XmlDiffPathSingleNodeList(); nodeList.AddNode(parentNode.ChildNodes); return nodeList; } else { XmlDiffPathNodeList nodeList = new XmlDiffPathMultiNodeList(); XmlDiffViewNode childNode = parentNode.ChildNodes; while (childNode != null) { nodeList.AddNode(childNode); childNode = childNode.NextSibbling; } return nodeList; } }
private void ApplyDiffgram(XmlNode diffgramParent, XmlDiffViewParentNode sourceParent) { sourceParent.CreateSourceNodesIndex(); XmlDiffViewNode currentPosition = null; IEnumerator diffgramChildren = diffgramParent.ChildNodes.GetEnumerator(); while (diffgramChildren.MoveNext()) { XmlNode diffgramNode = (XmlNode)diffgramChildren.Current; if (diffgramNode.NodeType == XmlNodeType.Comment) { continue; } XmlElement diffgramElement = diffgramChildren.Current as XmlElement; if (diffgramElement == null) { throw new Exception("Invalid node in diffgram."); } if (diffgramElement.NamespaceURI != XmlDiff.NamespaceUri) { throw new Exception("Invalid element in diffgram."); } string matchAttr = diffgramElement.GetAttribute("match"); XmlDiffPathNodeList matchNodes = null; if (matchAttr != string.Empty) { matchNodes = XmlDiffPath.SelectNodes(_doc, sourceParent, matchAttr); } switch (diffgramElement.LocalName) { case "node": if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'node' element must select a single node."); } matchNodes.MoveNext(); if (diffgramElement.ChildNodes.Count > 0) { ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)matchNodes.Current); } currentPosition = matchNodes.Current; break; case "add": if (matchAttr != string.Empty) { OnAddMatch(diffgramElement, matchNodes, sourceParent, ref currentPosition); } else { string typeAttr = diffgramElement.GetAttribute("type"); if (typeAttr != string.Empty) { OnAddNode(diffgramElement, typeAttr, sourceParent, ref currentPosition); } else { OnAddFragment(diffgramElement, sourceParent, ref currentPosition); } } break; case "remove": OnRemove(diffgramElement, matchNodes, sourceParent, ref currentPosition); break; case "change": OnChange(diffgramElement, matchNodes, sourceParent, ref currentPosition); break; } } }
private void ApplyDiffgram(XmlNode diffgramParent, XmlDiffViewParentNode sourceParent) { sourceParent.CreateSourceNodesIndex(); XmlDiffViewNode currentPosition = null; var enumerator = diffgramParent.ChildNodes.GetEnumerator(); while (enumerator.MoveNext()) { if (((XmlNode)enumerator.Current).NodeType != XmlNodeType.Comment) { if (!(enumerator.Current is XmlElement)) { throw new Exception("Invalid node in diffgram."); } var current = enumerator.Current as XmlElement; if (current.NamespaceURI != "http://schemas.microsoft.com/xmltools/2002/xmldiff") { throw new Exception("Invalid element in diffgram."); } var attribute1 = current.GetAttribute("match"); XmlDiffPathNodeList matchNodes = null; if (attribute1 != string.Empty) { matchNodes = XmlDiffPath.SelectNodes(this._doc, sourceParent, attribute1); } switch (current.LocalName) { case "node": if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'node' element must select a single node."); } matchNodes.MoveNext(); if (current.ChildNodes.Count > 0) { this.ApplyDiffgram(current, (XmlDiffViewParentNode)matchNodes.Current); } currentPosition = matchNodes.Current; continue; case "add": if (attribute1 != string.Empty) { this.OnAddMatch(current, matchNodes, sourceParent, ref currentPosition); continue; } var attribute2 = current.GetAttribute("type"); if (attribute2 != string.Empty) { this.OnAddNode(current, attribute2, sourceParent, ref currentPosition); continue; } this.OnAddFragment(current, sourceParent, ref currentPosition); continue; case "remove": this.OnRemove(current, matchNodes, sourceParent, ref currentPosition); continue; case "change": this.OnChange(current, matchNodes, sourceParent, ref currentPosition); continue; default: continue; } } } }
/// <summary> /// Tag the relocated data /// </summary> /// <param name="diffgramElement">node in diffgram</param> /// <param name="matchNodes">the path to the baseline node</param> /// <param name="sourceParent">the baseline parent node</param> /// <param name="currentPosition">the resulting node</param> private void OnRemove( XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { // opid & descriptor XmlDiffViewOperation operation = XmlDiffViewOperation.Remove; int operationId = 0; OperationDescriptor operationDesc = null; string opidAttr = diffgramElement.GetAttribute("opid"); if (opidAttr != string.Empty) { operationId = int.Parse(opidAttr); operationDesc = this.GetDescriptor(operationId); if (operationDesc.OperationType == OperationDescriptor.Type.Move) { operation = XmlDiffViewOperation.MoveFrom; } } else { operationId = NextOperationId; } // subtree string subtreeAttr = diffgramElement.GetAttribute("subtree"); bool subtree = (subtreeAttr != "no"); if (!subtree) { if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'remove' " + "element must select a single node when the 'subtree' " + "attribute is specified."); } // annotate node matchNodes.MoveNext(); XmlDiffViewNode node = matchNodes.Current; this.AnnotateNode(node, operation, operationId, false); if (operationId != 0 && operationDesc != null) { operationDesc.NodeList.AddNode(node); } // recurse this.ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)node); } else { // annotate nodes matchNodes.Reset(); while (matchNodes.MoveNext()) { if (operationId != 0 && operationDesc != null) { operationDesc.NodeList.AddNode(matchNodes.Current); } this.AnnotateNode(matchNodes.Current, operation, operationId, true); } } }
/// <summary> /// Gets the list of child nodes below the position indicated /// </summary> /// <param name="parentNode">The current node</param> /// <param name="path">Proprietary path statement</param> /// <param name="startPos">Position in the path statement /// at which to start collecting node objects.</param> /// <returns>list of child nodes</returns> /// <returns>List of nodes or attributes</returns> private static XmlDiffPathNodeList SelectChildNodes( XmlDiffViewParentNode parentNode, string path, int startPos) { int pos = startPos; XmlDiffPathNodeList nodeList = null; for (; ; ) { int nodePos = ReadPosition(path, ref pos); if (pos == path.Length) { nodeList = new XmlDiffPathSingleNodeList(); } else { nodeList = new XmlDiffPathMultiNodeList(); } if (nodePos <= 0 || nodePos > parentNode.SourceChildNodesCount) { OnNoMatchingNode(path); } nodeList.AddNode(parentNode.GetSourceChildNode(nodePos - 1)); if (pos == path.Length) { break; } else if (path[pos] == '|') { pos++; } else if (path[pos] == '-') { pos++; int endNodePos = ReadPosition(path, ref pos); if (endNodePos <= 0 || endNodePos > parentNode.SourceChildNodesCount) { OnNoMatchingNode(path); } while (nodePos < endNodePos) { nodePos++; nodeList.AddNode(parentNode.GetSourceChildNode(nodePos - 1)); } if (pos == path.Length) { break; } else if (path[pos] == '|') { pos++; } else { OnInvalidExpression(path); } } } return nodeList; }
/// <summary> /// Add the new fragment /// </summary> /// <param name="diffgramElement">node in diffgram</param> /// <param name="sourceParent">the baseline parent node</param> /// <param name="currentPosition">the resulting node</param> private void OnAddFragment( XmlElement diffgramElement, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { int opid = NextOperationId; IEnumerator childNodes = diffgramElement.ChildNodes.GetEnumerator(); while (childNodes.MoveNext()) { XmlDiffViewNode newChildNode = this.ImportNode( (XmlNode)childNodes.Current); sourceParent.InsertChildAfter( newChildNode, currentPosition, false); currentPosition = newChildNode; this.AnnotateNode( newChildNode, XmlDiffViewOperation.Add, opid, true); } }
/// <summary> /// Recurses through the baseline document loading the /// contents to the XmlDiffViewDocument object and tagging /// the pieces to be ignored later when the data is output. /// </summary> /// <param name="parent">Parent node</param> /// <param name="reader">The xml data</param> /// <param name="emptyElement">Node has no children</param> private void LoadSourceChildNodes( XmlDiffViewParentNode parent, XmlReader reader, bool emptyElement) { LoadState savedLoadState = this.loadState; this.loadState.Reset(); // load attributes while (reader.MoveToNextAttribute()) { XmlDiffViewAttribute attr; if (reader.Prefix == "xmlns" || (reader.Prefix == string.Empty && reader.LocalName == "xmlns")) { // create new DiffView attribute attr = new XmlDiffViewAttribute( reader.LocalName, reader.Prefix, reader.NamespaceURI, reader.Value); if (this.ignoreNamespaces) { // set the output operation to be performed attr.Operation = XmlDiffViewOperation.Ignore; } } else { string attrValue = this.ignoreWhitespace ? NormalizeText(reader.Value) : reader.Value; attr = new XmlDiffViewAttribute( reader.LocalName, reader.Prefix, reader.NamespaceURI, attrValue); } ((XmlDiffViewElement)parent).InsertAttributeAfter( attr, this.loadState.LastAttribute); this.loadState.LastAttribute = attr; } // empty element -> return, do not load chilren if (emptyElement) { goto End; } // load children while (reader.Read()) { // ignore whitespaces between nodes if (reader.NodeType == XmlNodeType.Whitespace) { continue; } XmlDiffViewNode child = null; switch (reader.NodeType) { case XmlNodeType.Element: bool emptyElementNode = reader.IsEmptyElement; XmlDiffViewElement elem = new XmlDiffViewElement( reader.LocalName, reader.Prefix, reader.NamespaceURI, this.ignorePrefixes); this.LoadSourceChildNodes(elem, reader, emptyElementNode); child = elem; break; case XmlNodeType.Attribute: string reason = "We should never get to this point, " + "attributes should be read at the beginning of this method."; Debug.Assert(false, reason); break; case XmlNodeType.Text: child = new XmlDiffViewCharData((this.ignoreWhitespace) ? NormalizeText(reader.Value) : reader.Value, XmlNodeType.Text); break; case XmlNodeType.CDATA: child = new XmlDiffViewCharData(reader.Value, XmlNodeType.CDATA); break; case XmlNodeType.EntityReference: Debug.Assert(false, "XmlDiffViewER was thought to be dead code"); // child = new XmlDiffViewER(reader.Name); break; case XmlNodeType.Comment: child = new XmlDiffViewCharData(reader.Value, XmlNodeType.Comment); if (this.ignoreComments) { child.Operation = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.ProcessingInstruction: child = new XmlDiffViewPI(reader.Name, reader.Value); if (this.ignorePI) { child.Operation = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.SignificantWhitespace: if (reader.XmlSpace == XmlSpace.Preserve) { child = new XmlDiffViewCharData(reader.Value, XmlNodeType.SignificantWhitespace); if (this.ignoreWhitespace) { child.Operation = XmlDiffViewOperation.Ignore; } } break; case XmlNodeType.XmlDeclaration: child = new XmlDiffViewXmlDeclaration(NormalizeText(reader.Value)); if (this.ignoreXmlDecl) { child.Operation = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.EndElement: goto End; case XmlNodeType.DocumentType: child = new XmlDiffViewDocumentType( reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); if (this.ignoreDtd) { child.Operation = XmlDiffViewOperation.Ignore; } break; default: Debug.Assert(false, "Invalid node type"); break; } parent.InsertChildAfter(child, this.loadState.LastChild, true); this.loadState.LastChild = child; } End: this.loadState = savedLoadState; }
/// <summary> /// Gets a list of node objects corresponding to /// the proprietary path reference provided. /// </summary> /// <param name="rootNode">The starting node</param> /// <param name="path">Absolute path reference to node of interest</param> /// <returns>list of node objects</returns> private static XmlDiffPathNodeList SelectAbsoluteNodes( XmlDiffViewParentNode rootNode, string path) { Debug.Assert(path[0] == '/'); int pos = 1; XmlDiffViewNode node = rootNode; for (; ; ) { int startPos = pos; int nodePos = ReadPosition(path, ref pos); if (pos == path.Length || path[pos] == '/') { if (node.FirstChildNode == null) { OnNoMatchingNode(path); } XmlDiffViewParentNode parentNode = (XmlDiffViewParentNode)node; if (nodePos <= 0 || nodePos > parentNode. SourceChildNodesCount) { OnNoMatchingNode(path); } node = parentNode.GetSourceChildNode(nodePos - 1); if (pos == path.Length) { XmlDiffPathNodeList list = new XmlDiffPathSingleNodeList(); list.AddNode(node); return list; } pos++; } else { if (path[pos] == '-' || path[pos] == '|') { if (node.FirstChildNode == null) { OnNoMatchingNode(path); } return SelectChildNodes( ((XmlDiffViewParentNode)node), path, startPos); } OnInvalidExpression(path); } } }
private void OnChange(XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { Debug.Assert(matchNodes.Count == 1); matchNodes.Reset(); matchNodes.MoveNext(); XmlDiffViewNode node = matchNodes.Current; if (node._nodeType != XmlNodeType.Attribute) { currentPosition = node; } XmlDiffViewNode.ChangeInfo changeInfo = new XmlDiffViewNode.ChangeInfo(); string name = diffgramElement.HasAttribute("name") ? diffgramElement.GetAttribute("name") : null; string prefix = diffgramElement.HasAttribute("prefix") ? diffgramElement.GetAttribute("prefix") : null; string ns = diffgramElement.HasAttribute("ns") ? diffgramElement.GetAttribute("ns") : null; switch (node._nodeType) { case XmlNodeType.Element: changeInfo._localName = (name == null)? ((XmlDiffViewElement)node)._localName : name; changeInfo._prefix = (prefix == null) ? ((XmlDiffViewElement)node)._prefix : prefix; changeInfo._ns = (ns == null) ? ((XmlDiffViewElement)node)._ns : ns; break; case XmlNodeType.Attribute: string value = diffgramElement.InnerText; if (name == string.Empty && prefix == string.Empty && value == string.Empty) { return; } changeInfo._localName = (name == null) ? ((XmlDiffViewAttribute)node)._localName : name; changeInfo._prefix = (prefix == null) ? ((XmlDiffViewAttribute)node)._prefix : prefix; changeInfo._ns = (ns == null) ? ((XmlDiffViewAttribute)node)._ns : ns; changeInfo._value = diffgramElement.InnerText; break; case XmlNodeType.Text: case XmlNodeType.CDATA: Debug.Assert(diffgramElement.FirstChild != null); changeInfo._value = diffgramElement.InnerText; break; case XmlNodeType.Comment: Debug.Assert(diffgramElement.FirstChild != null); Debug.Assert(diffgramElement.FirstChild.NodeType == XmlNodeType.Comment); changeInfo._value = diffgramElement.FirstChild.Value; break; case XmlNodeType.ProcessingInstruction: if (name == null) { Debug.Assert(diffgramElement.FirstChild != null); Debug.Assert(diffgramElement.FirstChild.NodeType == XmlNodeType.ProcessingInstruction); changeInfo._localName = diffgramElement.FirstChild.Name; changeInfo._value = diffgramElement.FirstChild.Value; } else { changeInfo._localName = name; changeInfo._value = ((XmlDiffViewPI)node)._value; } break; case XmlNodeType.EntityReference: Debug.Assert(name != null); changeInfo._localName = name; break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.FirstChild != null); changeInfo._value = diffgramElement.InnerText; break; case XmlNodeType.DocumentType: changeInfo._localName = (name == null) ? ((XmlDiffViewDocumentType)node)._name : name; if (diffgramElement.HasAttribute("publicId")) { changeInfo._prefix = diffgramElement.GetAttribute("publicId"); } else { changeInfo._prefix = ((XmlDiffViewDocumentType)node)._publicId; } if (diffgramElement.HasAttribute("systemId")) { changeInfo._ns = diffgramElement.GetAttribute("systemId"); } else { changeInfo._ns = ((XmlDiffViewDocumentType)node)._systemId; } if (diffgramElement.FirstChild != null) { changeInfo._value = diffgramElement.InnerText; } else { changeInfo._value = ((XmlDiffViewDocumentType)node)._subset; } break; default: Debug.Assert(false, "Invalid node type."); break; } node._changeInfo = changeInfo; node._op = XmlDiffViewOperation.Change; string opidAttr = diffgramElement.GetAttribute("opid"); if (opidAttr != string.Empty) { node._opid = int.Parse(opidAttr); } if (node._nodeType == XmlNodeType.Element && diffgramElement.FirstChild != null) { ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)node); } }
/// <summary> /// Loops through the child nodes of the diffgram and /// annotates the nodes with the type of operation, e.g., /// add, change, remove, etc. /// </summary> /// <param name="diffgramParent">node in diffgram data</param> /// <param name="sourceParent">node in baseline data</param> private void ApplyDiffgram( XmlNode diffgramParent, XmlDiffViewParentNode sourceParent) { sourceParent.CreateSourceNodesIndex(); XmlDiffViewNode currentPosition = null; IEnumerator diffgramChildren = diffgramParent.ChildNodes.GetEnumerator(); while (diffgramChildren.MoveNext()) { XmlNode diffgramNode = (XmlNode)diffgramChildren.Current; if (diffgramNode.NodeType == XmlNodeType.Comment) { continue; } XmlElement diffgramElement = diffgramChildren.Current as XmlElement; if (diffgramElement == null) { Trace.WriteLine("Invalid node in diffgram."); throw new InvalidOperationException( "Invalid node in diffgram."); } if (diffgramElement.NamespaceURI != XmlDiff.NamespaceUri) { Trace.WriteLine("Invalid element in diffgram."); throw new InvalidOperationException( "Invalid element in diffgram."); } string matchAttr = diffgramElement.GetAttribute("match"); XmlDiffPathNodeList matchNodes = null; if (matchAttr != string.Empty) { matchNodes = XmlDiffPath.SelectNodes( this.viewDocument, sourceParent, matchAttr); } switch (diffgramElement.LocalName) { case "node": if (matchNodes.Count != 1) { string message = "The 'match' attribute of " + "'node' element must select a single node."; throw new InvalidOperationException(message); } matchNodes.MoveNext(); if (diffgramElement.ChildNodes.Count > 0) { this.ApplyDiffgram( diffgramElement, (XmlDiffViewParentNode)matchNodes.Current); } currentPosition = matchNodes.Current; break; case "add": if (matchAttr != string.Empty) { this.OnAddMatch( diffgramElement, matchNodes, sourceParent, ref currentPosition); } else { string typeAttr = diffgramElement.GetAttribute( "type"); if (typeAttr != string.Empty) { this.OnAddNode( diffgramElement, typeAttr, sourceParent, ref currentPosition); } else { this.OnAddFragment( diffgramElement, sourceParent, ref currentPosition); } } break; case "remove": this.OnRemove( diffgramElement, matchNodes, sourceParent, ref currentPosition); break; case "change": this.OnChange( diffgramElement, matchNodes, sourceParent, ref currentPosition); break; } } }
private void LoadSourceChildNodes( XmlDiffViewParentNode parent, XmlReader reader, bool bEmptyElement) { var loadState = this._loadState; this._loadState.Reset(); while (reader.MoveToNextAttribute()) { XmlDiffViewAttribute newAttr; if (reader.Prefix == "xmlns" || reader.Prefix == string.Empty && reader.LocalName == "xmlns") { newAttr = new XmlDiffViewAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, reader.Value); if (this._bIgnoreNamespaces) { newAttr._op = XmlDiffViewOperation.Ignore; } } else { var str = this._bIgnoreWhitespace ? XmlDiffView.NormalizeText(reader.Value) : reader.Value; newAttr = new XmlDiffViewAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, str); } ((XmlDiffViewElement)parent).InsertAttributeAfter(newAttr, this._loadState._curLastAttribute); this._loadState._curLastAttribute = newAttr; } if (!bEmptyElement) { while (reader.Read()) { if (reader.NodeType != XmlNodeType.Whitespace) { XmlDiffViewNode newChild = null; switch (reader.NodeType) { case XmlNodeType.Element: var isEmptyElement = reader.IsEmptyElement; var xmlDiffViewElement = new XmlDiffViewElement(reader.LocalName, reader.Prefix, reader.NamespaceURI, this._bIgnorePrefixes); this.LoadSourceChildNodes(xmlDiffViewElement, reader, isEmptyElement); newChild = xmlDiffViewElement; break; case XmlNodeType.Attribute: Debug.Assert(false, "We should never get to this point, attributes should be read at the beginning of thid method."); break; case XmlNodeType.Text: newChild = new XmlDiffViewCharData(this._bIgnoreWhitespace ? XmlDiffView.NormalizeText(reader.Value) : reader.Value, XmlNodeType.Text); break; case XmlNodeType.CDATA: newChild = new XmlDiffViewCharData(reader.Value, XmlNodeType.CDATA); break; case XmlNodeType.EntityReference: newChild = new XmlDiffViewER(reader.Name); break; case XmlNodeType.ProcessingInstruction: newChild = new XmlDiffViewPI(reader.Name, reader.Value); if (this._bIgnorePI) { newChild._op = XmlDiffViewOperation.Ignore; break; } break; case XmlNodeType.Comment: newChild = new XmlDiffViewCharData(reader.Value, XmlNodeType.Comment); if (this._bIgnoreComments) { newChild._op = XmlDiffViewOperation.Ignore; break; } break; case XmlNodeType.DocumentType: newChild = new XmlDiffViewDocumentType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); if (this._bIgnoreDtd) { newChild._op = XmlDiffViewOperation.Ignore; break; } break; case XmlNodeType.SignificantWhitespace: if (reader.XmlSpace == XmlSpace.Preserve) { newChild = new XmlDiffViewCharData(reader.Value, XmlNodeType.SignificantWhitespace); if (this._bIgnoreWhitespace) { newChild._op = XmlDiffViewOperation.Ignore; break; } break; } break; case XmlNodeType.EndElement: goto label_29; case XmlNodeType.XmlDeclaration: newChild = new XmlDiffViewXmlDeclaration(XmlDiffView.NormalizeText(reader.Value)); if (this._bIgnoreXmlDecl) { newChild._op = XmlDiffViewOperation.Ignore; break; } break; default: Debug.Assert(false, "Invalid node type"); break; } parent.InsertChildAfter(newChild, this._loadState._curLastChild, true); this._loadState._curLastChild = newChild; } } } label_29: this._loadState = loadState; }
private void LoadSourceChildNodes(XmlDiffViewParentNode parent, XmlReader reader, bool bEmptyElement) { LoadState savedLoadState = _loadState; _loadState.Reset(); // load attributes while (reader.MoveToNextAttribute()) { XmlDiffViewAttribute attr; if (reader.Prefix == "xmlns" || (reader.Prefix == string.Empty && reader.LocalName == "xmlns")) { attr = new XmlDiffViewAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, reader.Value); if (_bIgnoreNamespaces) { attr._op = XmlDiffViewOperation.Ignore; } } else { string attrValue = _bIgnoreWhitespace ? NormalizeText(reader.Value) : reader.Value; attr = new XmlDiffViewAttribute(reader.LocalName, reader.Prefix, reader.NamespaceURI, attrValue); } ((XmlDiffViewElement)parent).InsertAttributeAfter(attr, _loadState._curLastAttribute); _loadState._curLastAttribute = attr; } // empty element -> return, do not load chilren if (bEmptyElement) { goto End; } // load children while (reader.Read()) { // ignore whitespaces between nodes if (reader.NodeType == XmlNodeType.Whitespace) { continue; } XmlDiffViewNode child = null; switch (reader.NodeType) { case XmlNodeType.Element: bool bEmptyEl = reader.IsEmptyElement; XmlDiffViewElement elem = new XmlDiffViewElement(reader.LocalName, reader.Prefix, reader.NamespaceURI, _bIgnorePrefixes); LoadSourceChildNodes(elem, reader, bEmptyEl); child = elem; break; case XmlNodeType.Attribute: Debug.Assert(false, "We should never get to this point, attributes should be read at the beginning of thid method."); break; case XmlNodeType.Text: child = new XmlDiffViewCharData((_bIgnoreWhitespace) ? NormalizeText(reader.Value) : reader.Value, XmlNodeType.Text); break; case XmlNodeType.CDATA: child = new XmlDiffViewCharData(reader.Value, XmlNodeType.CDATA); break; case XmlNodeType.EntityReference: child = new XmlDiffViewER(reader.Name); break; case XmlNodeType.Comment: child = new XmlDiffViewCharData(reader.Value, XmlNodeType.Comment); if (_bIgnoreComments) { child._op = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.ProcessingInstruction: child = new XmlDiffViewPI(reader.Name, reader.Value); if (_bIgnorePI) { child._op = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.SignificantWhitespace: if (reader.XmlSpace == XmlSpace.Preserve) { child = new XmlDiffViewCharData(reader.Value, XmlNodeType.SignificantWhitespace); if (_bIgnoreWhitespace) { child._op = XmlDiffViewOperation.Ignore; } } break; case XmlNodeType.XmlDeclaration: child = new XmlDiffViewXmlDeclaration(NormalizeText(reader.Value)); if (_bIgnoreXmlDecl) { child._op = XmlDiffViewOperation.Ignore; } break; case XmlNodeType.EndElement: goto End; case XmlNodeType.DocumentType: child = new XmlDiffViewDocumentType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); if (_bIgnoreDtd) { child._op = XmlDiffViewOperation.Ignore; } break; default: Debug.Assert(false, "Invalid node type"); break; } parent.InsertChildAfter(child, _loadState._curLastChild, true); _loadState._curLastChild = child; } End: _loadState = savedLoadState; }
/// <summary> /// Relocate matched data. /// </summary> /// <param name="diffgramElement">node in diffgram</param> /// <param name="matchNodes">the path to the baseline node</param> /// <param name="sourceParent">the baseline parent node</param> /// <param name="currentPosition">the resulting node</param> private void OnAddMatch( XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { string opidAttr = diffgramElement.GetAttribute("opid"); if (opidAttr == string.Empty) { throw new Exception("Missing opid attribute."); } // opid & descriptor int opid = ParseOpId(opidAttr); OperationDescriptor operationDesc = this.GetDescriptor(opid); string subtreeAttr = diffgramElement.GetAttribute("subtree"); bool subtree = (subtreeAttr != "no"); // move single node without subtree if (!subtree) { if (matchNodes.Count != 1) { throw new Exception("The 'match' attribute of 'add' " + "element must select a single node when the 'subtree' " + "attribute is specified."); } // clone node matchNodes.MoveNext(); XmlDiffViewNode newNode = matchNodes.Current.Clone(false); this.AnnotateNode( newNode, XmlDiffViewOperation.MoveTo, opid, true); operationDesc.NodeList.AddNode(newNode); // insert in tree sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; // recurse this.ApplyDiffgram( diffgramElement, (XmlDiffViewParentNode)newNode); } else { // move subtree matchNodes.Reset(); while (matchNodes.MoveNext()) { XmlDiffViewNode newNode = matchNodes.Current.Clone(true); this.AnnotateNode( newNode, XmlDiffViewOperation.MoveTo, opid, true); operationDesc.NodeList.AddNode(newNode); sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; } } }
private static XmlDiffPathNodeList SelectChildNodes( XmlDiffViewParentNode parentNode, string path, int startPos) { var pos = startPos; XmlDiffPathNodeList diffPathNodeList; while (true) { int num1; do { num1 = XmlDiffPath.ReadPosition(path, ref pos); diffPathNodeList = pos != path.Length ? (XmlDiffPathNodeList) new XmlDiffPathMultiNodeList() : (XmlDiffPathNodeList) new XmlDiffPathSingleNodeList(); if (num1 <= 0 || num1 > parentNode._sourceChildNodesCount) { XmlDiffPath.OnNoMatchingNode(path); } diffPathNodeList.AddNode(parentNode.GetSourceChildNode(num1 - 1)); if (pos != path.Length) { if (path[pos] == '|') { ++pos; } } else { goto label_15; } }while (path[pos] != '-'); ++pos; var num2 = XmlDiffPath.ReadPosition(path, ref pos); if (num2 <= 0 || num2 > parentNode._sourceChildNodesCount) { XmlDiffPath.OnNoMatchingNode(path); } while (num1 < num2) { ++num1; diffPathNodeList.AddNode(parentNode.GetSourceChildNode(num1 - 1)); } if (pos != path.Length) { if (path[pos] == '|') { ++pos; } else { XmlDiffPath.OnInvalidExpression(path); } } else { break; } } label_15: return(diffPathNodeList); }
private void OnAddNode( XmlElement diffgramElement, string nodeTypeAttr, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { var nodeType = (XmlNodeType)int.Parse(nodeTypeAttr); var attribute1 = diffgramElement.GetAttribute("name"); var attribute2 = diffgramElement.GetAttribute("prefix"); var attribute3 = diffgramElement.GetAttribute("ns"); var attribute4 = diffgramElement.GetAttribute("opid"); var num = attribute4 == string.Empty ? 0 : int.Parse(attribute4); if (nodeType == XmlNodeType.Attribute) { Debug.Assert(attribute1 != string.Empty); var newAttr = new XmlDiffViewAttribute(attribute1, attribute2, attribute3, diffgramElement.InnerText); newAttr._op = XmlDiffViewOperation.Add; newAttr._opid = num; ((XmlDiffViewElement)sourceParent).InsertAttributeAfter(newAttr, null); } else { XmlDiffViewNode newChild = null; switch (nodeType) { case XmlNodeType.Element: Debug.Assert(attribute1 != string.Empty); newChild = new XmlDiffViewElement(attribute1, attribute2, attribute3, this._bIgnorePrefixes); this.ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)newChild); break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: Debug.Assert(diffgramElement.InnerText != string.Empty); newChild = new XmlDiffViewCharData(diffgramElement.InnerText, nodeType); break; case XmlNodeType.EntityReference: Debug.Assert(attribute1 != string.Empty); newChild = new XmlDiffViewER(attribute1); break; case XmlNodeType.ProcessingInstruction: Debug.Assert(diffgramElement.InnerText != string.Empty); Debug.Assert(attribute1 != string.Empty); newChild = new XmlDiffViewPI(attribute1, diffgramElement.InnerText); break; case XmlNodeType.DocumentType: newChild = new XmlDiffViewDocumentType(diffgramElement.GetAttribute("name"), diffgramElement.GetAttribute("publicId"), diffgramElement.GetAttribute("systemId"), diffgramElement.InnerText); break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.InnerText != string.Empty); newChild = new XmlDiffViewXmlDeclaration(diffgramElement.InnerText); break; default: Debug.Assert(false, "Invalid node type."); break; } Debug.Assert(newChild != null); newChild._op = XmlDiffViewOperation.Add; newChild._opid = num; sourceParent.InsertChildAfter(newChild, currentPosition, false); currentPosition = newChild; } }
/// <summary> /// Add the new node or attribute /// </summary> /// <param name="diffgramElement">node in diffgram</param> /// <param name="nodeTypeAttr">Whether this is an Attribute</param> /// <param name="sourceParent">the baseline parent node</param> /// <param name="currentPosition">the resulting node</param> private void OnAddNode( XmlElement diffgramElement, string nodeTypeAttr, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { XmlNodeType nodeType = (XmlNodeType) int.Parse(nodeTypeAttr); string name = diffgramElement.GetAttribute("name"); string prefix = diffgramElement.GetAttribute("prefix"); string ns = diffgramElement.GetAttribute("ns"); string opidAttr = diffgramElement.GetAttribute("opid"); int opid = ParseOpId(opidAttr); if (nodeType == XmlNodeType.Attribute) { Debug.Assert(name != string.Empty); XmlDiffViewAttribute newAttr = new XmlDiffViewAttribute( name, prefix, ns, diffgramElement.InnerText); newAttr.Operation = XmlDiffViewOperation.Add; newAttr.OperationId = opid; ((XmlDiffViewElement) sourceParent).InsertAttributeAfter(newAttr, null); } else { XmlDiffViewNode newNode = null; switch (nodeType) { case XmlNodeType.Element: Debug.Assert(name != string.Empty); newNode = new XmlDiffViewElement( name, prefix, ns, this.ignorePrefixes); this.ApplyDiffgram( diffgramElement, (XmlDiffViewParentNode)newNode); break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.Comment: Debug.Assert(diffgramElement.InnerText != string.Empty); newNode = new XmlDiffViewCharData( diffgramElement.InnerText, nodeType); break; case XmlNodeType.ProcessingInstruction: Debug.Assert(diffgramElement.InnerText != string.Empty); Debug.Assert(name != string.Empty); newNode = new XmlDiffViewPI( name, diffgramElement.InnerText); break; case XmlNodeType.EntityReference: Debug.Assert(name != string.Empty); Debug.Assert(false, "XmlDiffViewER was thought to be dead code"); //// newNode = new XmlDiffViewER(name); break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.InnerText != string.Empty); newNode = new XmlDiffViewXmlDeclaration( diffgramElement.InnerText); break; case XmlNodeType.DocumentType: newNode = new XmlDiffViewDocumentType( diffgramElement.GetAttribute("name"), diffgramElement.GetAttribute("publicId"), diffgramElement.GetAttribute("systemId"), diffgramElement.InnerText); break; default: Debug.Assert(false, "Invalid node type."); break; } Debug.Assert(newNode != null); newNode.Operation = XmlDiffViewOperation.Add; newNode.OperationId = opid; sourceParent.InsertChildAfter(newNode, currentPosition, false); currentPosition = newNode; } }
private void OnChange( XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { Debug.Assert(matchNodes.Count == 1); matchNodes.Reset(); matchNodes.MoveNext(); var current = matchNodes.Current; if (current._nodeType != XmlNodeType.Attribute) { currentPosition = current; } var changeInfo = new XmlDiffViewNode.ChangeInfo(); var str1 = diffgramElement.HasAttribute("name") ? diffgramElement.GetAttribute("name") : null; var str2 = diffgramElement.HasAttribute("prefix") ? diffgramElement.GetAttribute("prefix") : null; var str3 = diffgramElement.HasAttribute("ns") ? diffgramElement.GetAttribute("ns") : null; switch (current._nodeType) { case XmlNodeType.Element: changeInfo._localName = str1 == null ? ((XmlDiffViewElement)current)._localName : str1; changeInfo._prefix = str2 == null ? ((XmlDiffViewElement)current)._prefix : str2; changeInfo._ns = str3 == null ? ((XmlDiffViewElement)current)._ns : str3; break; case XmlNodeType.Attribute: var innerText = diffgramElement.InnerText; if (str1 == string.Empty && str2 == string.Empty && innerText == string.Empty) { return; } changeInfo._localName = str1 == null ? ((XmlDiffViewAttribute)current)._localName : str1; changeInfo._prefix = str2 == null ? ((XmlDiffViewAttribute)current)._prefix : str2; changeInfo._ns = str3 == null ? ((XmlDiffViewAttribute)current)._ns : str3; changeInfo._value = diffgramElement.InnerText; break; case XmlNodeType.Text: case XmlNodeType.CDATA: Debug.Assert(diffgramElement.FirstChild != null); changeInfo._value = diffgramElement.InnerText; break; case XmlNodeType.EntityReference: Debug.Assert(str1 != null); changeInfo._localName = str1; break; case XmlNodeType.ProcessingInstruction: if (str1 == null) { Debug.Assert(diffgramElement.FirstChild != null); Debug.Assert(diffgramElement.FirstChild.NodeType == XmlNodeType.ProcessingInstruction); changeInfo._localName = diffgramElement.FirstChild.Name; changeInfo._value = diffgramElement.FirstChild.Value; break; } changeInfo._localName = str1; changeInfo._value = ((XmlDiffViewCharData)current)._value; break; case XmlNodeType.Comment: Debug.Assert(diffgramElement.FirstChild != null); Debug.Assert(diffgramElement.FirstChild.NodeType == XmlNodeType.Comment); changeInfo._value = diffgramElement.FirstChild.Value; break; case XmlNodeType.DocumentType: changeInfo._localName = str1 == null ? ((XmlDiffViewDocumentType)current)._name : str1; changeInfo._prefix = !diffgramElement.HasAttribute("publicId") ? ((XmlDiffViewDocumentType)current)._publicId : diffgramElement.GetAttribute("publicId"); changeInfo._ns = !diffgramElement.HasAttribute("systemId") ? ((XmlDiffViewDocumentType)current)._systemId : diffgramElement.GetAttribute("systemId"); changeInfo._value = diffgramElement.FirstChild == null ? ((XmlDiffViewDocumentType)current)._subset : diffgramElement.InnerText; break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.FirstChild != null); changeInfo._value = diffgramElement.InnerText; break; default: Debug.Assert(false, "Invalid node type."); break; } current._changeInfo = changeInfo; current._op = XmlDiffViewOperation.Change; var attribute = diffgramElement.GetAttribute("opid"); if (attribute != string.Empty) { current._opid = int.Parse(attribute); } if (current._nodeType != XmlNodeType.Element || diffgramElement.FirstChild == null) { return; } this.ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)current); }
/// <summary> /// Store changes in the ChangeInfo object of the marked-up-baseline node /// </summary> /// <param name="diffgramElement">current element in the diffgram</param> /// <param name="matchNodes">Object containing the list of baseline nodes /// which match the position in the diffgram</param> /// <param name="sourceParent">parent node in the baseline data</param> /// <param name="currentPosition">current position</param> private void OnChange( XmlElement diffgramElement, XmlDiffPathNodeList matchNodes, XmlDiffViewParentNode sourceParent, ref XmlDiffViewNode currentPosition) { Debug.Assert(matchNodes.Count == 1); matchNodes.Reset(); matchNodes.MoveNext(); XmlDiffViewNode node = matchNodes.Current; if (node.NodeType != XmlNodeType.Attribute) { currentPosition = node; } XmlDiffViewNode.ChangeInfo changeInfo = new XmlDiffViewNode.ChangeInfo(); string name = diffgramElement.HasAttribute("name") ? diffgramElement.GetAttribute("name") : null; string prefix = diffgramElement.HasAttribute("prefix") ? diffgramElement.GetAttribute("prefix") : null; string ns = diffgramElement.HasAttribute("ns") ? diffgramElement.GetAttribute("ns") : null; switch (node.NodeType) { case XmlNodeType.Element: changeInfo.LocalName = (name == null) ? ((XmlDiffViewElement)node).LocalName : name; changeInfo.Prefix = (prefix == null) ? ((XmlDiffViewElement)node).Prefix : prefix; changeInfo.NamespaceUri = (ns == null) ? ((XmlDiffViewElement)node).NamespaceUri : ns; break; case XmlNodeType.Attribute: string value = diffgramElement.InnerText; if (name == string.Empty && prefix == string.Empty && value == string.Empty) { return; } changeInfo.LocalName = (name == null) ? ((XmlDiffViewAttribute)node).LocalName : name; changeInfo.Prefix = (prefix == null) ? ((XmlDiffViewAttribute)node).Prefix : prefix; changeInfo.NamespaceUri = (ns == null) ? ((XmlDiffViewAttribute)node).NamespaceUri : ns; changeInfo.Subset = diffgramElement.InnerText; break; case XmlNodeType.Text: case XmlNodeType.CDATA: Debug.Assert(diffgramElement.FirstChild != null); changeInfo.Subset = diffgramElement.InnerText; break; case XmlNodeType.Comment: Debug.Assert(diffgramElement.FirstChild != null); Debug.Assert(diffgramElement.FirstChild.NodeType == XmlNodeType.Comment); changeInfo.Subset = diffgramElement.FirstChild.Value; break; case XmlNodeType.ProcessingInstruction: if (name == null) { Debug.Assert(diffgramElement.FirstChild != null); Debug.Assert(diffgramElement.FirstChild.NodeType == XmlNodeType.ProcessingInstruction); changeInfo.LocalName = diffgramElement.FirstChild.Name; changeInfo.Subset = diffgramElement.FirstChild.Value; } else { changeInfo.LocalName = name; changeInfo.Subset = ((XmlDiffViewPI)node).InnerText; } break; case XmlNodeType.EntityReference: Debug.Assert(name != null); changeInfo.LocalName = name; break; case XmlNodeType.XmlDeclaration: Debug.Assert(diffgramElement.FirstChild != null); changeInfo.Subset = diffgramElement.InnerText; break; case XmlNodeType.DocumentType: changeInfo.LocalName = (name == null) ? ((XmlDiffViewDocumentType)node).Name : name; if (diffgramElement.HasAttribute("publicId")) { changeInfo.Prefix = diffgramElement.GetAttribute("publicId"); } else { changeInfo.Prefix = ((XmlDiffViewDocumentType)node).PublicId; } if (diffgramElement.HasAttribute("systemId")) { changeInfo.NamespaceUri = diffgramElement.GetAttribute("systemId"); } else { changeInfo.NamespaceUri = ((XmlDiffViewDocumentType)node).SystemId; } if (diffgramElement.FirstChild != null) { changeInfo.Subset = diffgramElement.InnerText; } else { changeInfo.Subset = ((XmlDiffViewDocumentType)node).Subset; } break; default: Debug.Assert(false, "Invalid node type."); break; } node.ChangeInformation = changeInfo; node.Operation = XmlDiffViewOperation.Change; string opidAttr = diffgramElement.GetAttribute("opid"); if (opidAttr != string.Empty) { node.OperationId = int.Parse(opidAttr); } else { node.OperationId = NextOperationId; } if (node.NodeType == XmlNodeType.Element && diffgramElement.FirstChild != null) { this.ApplyDiffgram(diffgramElement, (XmlDiffViewParentNode)node); } }