예제 #1
0
        /// <summary>
        /// Build a tree of only one schema
        /// </summary>
        /// <param name="schemaA"></param>
        /// <returns></returns>
        public IDiffNode BuildTree(XmlSchemaObject obj)
        {
            // Setup the schema
            IDiffNode retVal = null;
            if (obj is XmlSchemaAttribute)
                retVal = new AttributeDiffNode() { Original = obj as XmlSchemaAttribute };
            else if (obj is XmlSchemaElement)
            {
                retVal = new ElementDiffNode() { Original = obj as XmlSchemaElement };
                CopyChildNodes((obj as XmlSchemaElement).SchemaType as XmlSchemaComplexType, retVal, new Stack<string>(), true);
            }
            else if (obj is XmlSchemaChoice)
            {
                retVal = new ChoiceDiffNode() { Original = obj as XmlSchemaChoice };
                CopyChildNodes(obj as XmlSchemaChoice, retVal, new Stack<string>());
                retVal = retVal.Children[0];
            }
            else if (obj is XmlSchemaSequence)
            {
                retVal = new SequenceDiffNode() { Original = obj as XmlSchemaSequence };
                CopyChildNodes(obj as XmlSchemaSequence, retVal, new Stack<string>());
                if (TreatSequenceAsNode)
                    retVal = retVal.Children[0];
            }
            else
                return null;

            return retVal;
        }
예제 #2
0
        /// <summary>
        /// Build a diff tree for the two schemas
        /// </summary>
        public DiffTree BuildTree(XmlSchemaSet schemaA, XmlSchemaSet schemaB)
        {

            // Setup the schema
            DiffTree retVal = new DiffTree() { Original = schemaA, Compared = schemaB };

            // Now add all of the nodes in schemaA to the diff tree
            if (schemaA.Elements == null ||
                schemaB.Elements == null ||
                schemaA.Elements.Count == 0 || schemaB.Elements.Count == 0)
                throw new InvalidOperationException("Both schemas must have at least one root element in order to compare");

            Stack<String> typeStack = new Stack<string>();

            // Root node
            int i = 0;
            foreach (XmlSchemaElement ele in schemaA.Elements)
            {
                i++;
                ElementDiffNode rootNode = new ElementDiffNode() { Original = ele };
                if (rootNode.Original.SchemaType is XmlSchemaComplexType)
                    CopyChildNodes(rootNode.Original.SchemaType as XmlSchemaComplexType, rootNode, typeStack, false);
                retVal.Nodes.Add(rootNode);

                // Comparing, let any listeners know that we're still working
                if (Comparing != null)
                    Comparing(this, ((float)i / schemaA.Elements.Count)/2);

            }

            // Comparison time... the DiffBuilder really just checks for added/removed nodes and places the NET nodes
            // into the tree...
            i = 0;
            foreach (XmlSchemaElement ele in schemaB.Elements)
            {
                i++;
                ElementDiffNode bRootNode = new ElementDiffNode() { Original = ele };
                if (bRootNode.Original.SchemaType is XmlSchemaComplexType)
                    CopyChildNodes(bRootNode.Original.SchemaType as XmlSchemaComplexType, bRootNode, typeStack, false);

                if (Comparing != null)
                    Comparing(this, (float)(((float)i / schemaB.Elements.Count) / 2 + 0.5));

                CompareNodes(retVal.Nodes, bRootNode, null);

                // Is this a new root node?
                if (retVal.Nodes.Find(o => o.FriendlyName == bRootNode.FriendlyName) == null)
                    retVal.Nodes.Add(bRootNode);
            }

            retVal.CalculateDiff();

            return retVal;
        }
예제 #3
0
        /// <summary>
        /// Copy element data
        /// </summary>
        private void CopyChildNodes(XmlSchemaElement element, IDiffNode parent, Stack<String> typeStack)
        {
            if (element.MaxOccurs == "0")
            {
                if (parent.Children != null)
                {
                    IDiffNode foundNode = parent.Children.Find(o => o.FriendlyName == element.Name);
                    parent.Children.Remove(foundNode);
                }
                return;
            }
            else if (parent.Children != null &&
                parent.Children.Find(o => o.FriendlyName == element.Name) != null)
                return;

            ElementDiffNode rootNode = new ElementDiffNode() { Original = element };
            if (rootNode.Original.SchemaType is XmlSchemaComplexType)
                CopyChildNodes(rootNode.Original.SchemaType as XmlSchemaComplexType, rootNode, typeStack, true);
            parent.AddChild(rootNode);
        }