Example #1
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);
        }
Example #2
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);
            }
        }