示例#1
0
        /// <summary>
        /// Vergleicht zwei Knotenbäume. Beide Knotenbäume werden dabei verändert.
        /// </summary>
        /// <param name="k1">Der eine Knotenbaum.</param>
        /// <param name="k2">Der andere Knotenbaum.</param>
        /// <returns><code>null</code>, falls beide Knoten identisch sind oder der geänderte
        /// k1-Knoten mit den Unterschieden.</returns>
        public Knoten Diff(Knoten k1, Knoten k2)
        {
            subtract(k1, k2);

            if (!k1.hasKinder() && !k2.hasKinder())
            {
                if (k1.Equals(k2))
                {
                    //beide Bäume sind identisch
                    return(null);
                }
            }

            return(k1);
        }
示例#2
0
        /**
         * Ermittelt eine Stringrepräsentation für den angegebenen Knoten.
         * @param k Der Knoten.
         * @return Die Stringdarstellung.
         */

        private static String getKnotenAsString(Knoten k)
        {
            StringBuilder sb = new StringBuilder();

            sb.Append(k.elementName);
            foreach (var e in k.attributes)
            {
                sb.Append(" ");
                sb.Append(e.Key);
                sb.Append("=\"");
                sb.Append(e.Value);
                sb.Append("\"");
            }

            return(sb.ToString());
        }
示例#3
0
        /**
         * Erzeugt aus dem angegebenen Node einen Knoten. Die Kinder werden berücksichtigt.
         * @param node Der zu konvertierende Node.
         * @return Ein Knoten, der dem Node entspricht.
         */

        public static Knoten createOf(XmlNode node)
        {
            Knoten parent = createKnoten(node);

            if (parent == null)
            {
                return(null);
            }

            XmlNodeList kids = node.ChildNodes;

            for (int i = 0, cnt = kids.Count; i < cnt; i++)
            {
                Knoten kind = createOf(kids.Item(i));
                if (kind != null)
                {
                    parent.addKind(kind);
                }
            }

            return(parent);
        }
示例#4
0
        private string diffWithDiffy(string firstXml, string secondXml)
        {
            try
            {
                XmlNode eines   = createDOM(XmlReader.Create(firstXml.ToStream()));
                XmlNode anderes = createDOM(XmlReader.Create(secondXml.ToStream()));

                Knoten ersterKnoten  = Knoten.createOf(eines);
                Knoten andererKnoten = Knoten.createOf(anderes);

                DiffEngine diff = new DiffEngine();
                Knoten     res  = diff.Diff(ersterKnoten, andererKnoten);

                if (res == null)
                {
                    return("XML files are equal");
                }
                else
                {
                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.Indent   = true;
                    settings.Encoding = XSConfiguration.Instance.Config.Encoding;

                    XmlDocument result = res.ToString().ToXmlDocument();

                    StringBuilder sb = new StringBuilder();
                    using (XmlWriter w = XmlWriter.Create(sb, settings))
                    {
                        result.WriteTo(w);
                    }

                    return(sb.ToString());
                }
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
        }
示例#5
0
        /**
         * Fügt den angegebenen Knoten als Kind dieses Knotens hinzu.
         * @param kind Das neue Kind.
         */

        public void addKind(Knoten kind)
        {
            kinder.Add(kind);
        }
示例#6
0
        /**
         * {@inheritDoc}
         */

        public override bool Equals(Object obj)
        {
            if (this == obj)
            {
                return(true);
            }
            if (obj == null)
            {
                return(false);
            }
            if (GetType() != obj.GetType())
            {
                return(false);
            }
            Knoten other = (Knoten)obj;

            if (attributes == null)
            {
                if (other.attributes != null)
                {
                    return(false);
                }
            }
            else if (!attributes.Equals(other.attributes))
            {
                return(false);
            }
            if (elementName == null)
            {
                if (other.elementName != null)
                {
                    return(false);
                }
            }
            else if (!elementName.Equals(other.elementName))
            {
                return(false);
            }
            if (kinder == null)
            {
                if (other.kinder != null)
                {
                    return(false);
                }
            }
            else if (!kinder.Equals(other.kinder))
            {
                return(false);
            }
            if (text == null)
            {
                if (other.text != null)
                {
                    return(false);
                }
            }
            else if (!text.Equals(other.text))
            {
                return(false);
            }
            if (typ == null)
            {
                if (other.typ != null)
                {
                    return(false);
                }
            }
            else if (!typ.Equals(other.typ))
            {
                return(false);
            }
            return(true);
        }
示例#7
0
        /**
         * Prüft, ob dieser und der angegebene Knoten gleich sind. Die Kinder werden dabei
         * nicht berücksichtigt. Ebenso wird Whitespace im Text nicht berücksichtigt.
         * @param other Der zu vergleichende Knoten.
         * @return <code>true</code>, falls die beiden Knoten gleich sind.
         * @see #equals(Object)
         */

        public bool equalsWithoutChildren(Knoten other)
        {
            if (GetType() != other.GetType())
            {
                Debug.Fail("");
                return(false);
            }
            if (attributes == null)
            {
                if (other.attributes != null)
                {
                    return(false);
                }
            }
            else if (!attributes.Equals(other.attributes))
            {
                return(false);
            }
            if (elementName == null)
            {
                if (other.elementName != null)
                {
                    return(false);
                }
            }
            else if (!elementName.Equals(other.elementName))
            {
                return(false);
            }
            //		if (kinder == null) {
            //			if (other.kinder != null) {
            //				return false;
            //			}
            //		} else if (!kinder.equals(other.kinder)) {
            //			return false;
            //		}
            if (text == null)
            {
                if (other.text != null)
                {
                    return(false);
                }
            }
            else
            {
                //Bei unterschiedlichen Kindern stimmt oft auch der Whitespace nicht
                String othertext = other.text == null ? null : other.text.Trim();
                if (!text.Trim().Equals(othertext))
                {
                    return(false);
                }
            }
            if (typ == null)
            {
                if (other.typ != null)
                {
                    return(false);
                }
            }
            else if (!typ.Equals(other.typ))
            {
                return(false);
            }
            return(true);
        }
示例#8
0
        /**
         * Löscht das angegebene Kind
         * @param kind Das zu löschende Kind
         */

        public void removeKind(Knoten kind)
        {
            bool success = kinder.Remove(kind);

            Debug.Assert(success, "Kind nicht gefunden: " + kind.ToString());
        }
示例#9
0
        /**
         * Subtrahiert die beiden Knoten voneinander.
         * @param minuend Der Minuend.
         * @param subtrahend Der Subtrahend.
         */

        private void subtract(Knoten minuend, Knoten subtrahend)
        {
            //Die Kinder können nicht sofort gelöscht werden, da sich sonst die Liste ändert
            //und man nicht mehr einfach durchiterieren kann
            List <Knoten> zuLoeschendeKinderMinu = new List <Knoten>();
            List <Knoten> zuLoeschendeKinderSubt = new List <Knoten>();
            List <Knoten> hinzuzufuegendeKinder  = new List <Knoten>();

            foreach (Knoten kind_minu in minuend.getKinder())
            {
                Knoten kind_subt = getKindWie(kind_minu, subtrahend);

                if (kind_subt != null)
                {
                    subtract(kind_minu, kind_subt);

                    if (!kind_minu.hasKinder() && !kind_subt.hasKinder())
                    {
                        if (kind_minu.Equals(kind_subt))
                        {
                            zuLoeschendeKinderMinu.Add(kind_minu);
                            zuLoeschendeKinderSubt.Add(kind_subt);
                            kind_minu.setIgnoreMe();
                            kind_subt.setIgnoreMe();
                        }
                    }
                    else
                    {
                        //
                    }
                }
                else
                {
                    Knoten k = new Knoten(
                        Knoten.KnotenTyp.GELOESCHT,
                        kind_minu.getName(),
                        kind_minu.getText(),
                        kind_minu.getAttributes());
                    k.setIgnoreMe();
                    hinzuzufuegendeKinder.Add(k);
                    zuLoeschendeKinderMinu.Add(kind_minu);
                }
            }

            foreach (Knoten loeschMich in zuLoeschendeKinderMinu)
            {
                minuend.removeKind(loeschMich);
            }
            foreach (Knoten loeschMich in zuLoeschendeKinderSubt)
            {
                subtrahend.removeKind(loeschMich);
            }

            if (subtrahend.hasKinder())
            {
                foreach (Knoten hinzugefuegtesKind in subtrahend.getKinder())
                {
                    Knoten kind_minu = getKindWie(hinzugefuegtesKind, minuend);

                    if (kind_minu == null)
                    {
                        Knoten k = new Knoten(
                            Knoten.KnotenTyp.HINZUGEFUEGT,
                            hinzugefuegtesKind.getName(),
                            hinzugefuegtesKind.getText(),
                            hinzugefuegtesKind.getAttributes());
                        k.setIgnoreMe();
                        hinzuzufuegendeKinder.Add(k);
                    }
                }
            }
            foreach (Knoten neu in hinzuzufuegendeKinder)
            {
                minuend.addKind(neu);
            }
        }
示例#10
0
        /**
         * Ermittelt aus dem Knotenbaum "parent" ein Kind, das so ähnlich ist wie "beispiel"
         * @param beispiel
         * @param parent
         * @return Das ähnliche Kind oder <code>null</code>, falls kein ähnliches Kind
         * existiert.
         */

        private static Knoten getKindWie(Knoten beispiel, Knoten parent)
        {
            Knoten gefunden    = null;
            Knoten gefunden2   = null;
            int    anzGefunden = 0;

            ICollection <Knoten> kids = parent.getKinder();

            foreach (Knoten kid in kids)
            {
                if (kid.isIgnoreMe())
                {
                    continue;
                }
                if (kid.equalsWithoutChildren(beispiel))
                {
                    if (gefunden == null)
                    {
                        //erstes übernehmen
                        gefunden = kid;
                    }
                    anzGefunden++;
                }
            }

            //wenn mehrere Kinder gemäß equalsWithoutChildren gefunden wurden, dann Suche eingrenzen
            //Prüfen, ob die Knoten überhaupt Kinder haben
            if (anzGefunden > 1)
            {
                anzGefunden = 0;
                foreach (Knoten kid in kids)
                {
                    if (kid.isIgnoreMe())
                    {
                        continue;
                    }
                    if (kid.equalsWithoutChildren(beispiel))
                    {
                        if (kid.getKinder().Count == beispiel.getKinder().Count)
                        {
                            if (gefunden2 == null)
                            {
                                gefunden2 = kid;
                            }
                            anzGefunden++;
                        }
                    }
                }
            }

            //wenn mehrere Kinder gemäß equalsWithoutChildren && Kinderanzahl gefunden wurden, dann Suche eingrenzen
            //Prüfen, ob die Knoten überhaupt Kinder haben
            if (anzGefunden > 1)
            {
                foreach (Knoten kid in kids)
                {
                    if (kid.isIgnoreMe())
                    {
                        continue;
                    }
                    if (kid.Equals(beispiel))
                    {
                        return(kid);
                    }
                }
            }

            if (gefunden2 != null)
            {
                return(gefunden2);
            }
            else
            {
                return(gefunden);
            }
        }