Пример #1
0
        /// <summary>
        /// parse an xml node
        /// </summary>
        /// <param name="xnod"></param>
        /// <param name="level"></param>
        public override void LoadFromXml(XmlNode xnod, int level)
        {
            LoadLinkFromXml(xnod, level);

            if (xnod.Name == "RelationshipType")
                SetRelationshipType(xnod.InnerText);

            if (xnod.Name == "PeopleRelationship")
            {
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    personality person = new personality();
                    person.LoadFromXml(xnod.ChildNodes[i], level);
                    if (i == 0)
                    {
                        atoms_incoming.Clear();
                        atoms_incoming.Add(person);
                    }
                    else
                    {
                        atoms_outgoing.Clear();
                        atoms_outgoing.Add(person);
                    }
                }
            }

            if (xnod.Name == "Started")
                SetStartedDate(DateTime.Parse(xnod.InnerText));

            if (xnod.Name == "Ended")
                SetEndedDate(DateTime.Parse(xnod.InnerText));

            if (xnod.Name == "Affect")
                affect = truthvalue.FromString(xnod.InnerText);

            if (xnod.Name == "Credibility")
                credibility = truthvalue.FromString(xnod.InnerText);

            if (xnod.Name == "Familiarity")
                familiarity = truthvalue.FromString(xnod.InnerText);

            if (xnod.Name == "InterpersonalProperties")
            {
                property.Clear();
                String[] props = xnod.InnerText.Split(',');
                for (int i = 0; i < props.Length; i++)
                {
                    property.Add(Convert.ToInt32(props[i]));
                }
            }

            // call recursively on all children of the current node
            if (xnod.HasChildNodes)
            {
                XmlNode xnodWorking = xnod.FirstChild;
                while (xnodWorking != null)
                {
                    LoadFromXml(xnodWorking, level + 1);
                    xnodWorking = xnodWorking.NextSibling;
                }
            }
        }
Пример #2
0
        /// <summary>
        /// parse an xml node
        /// </summary>
        /// <param name="xnod"></param>
        /// <param name="level"></param>
        public override void LoadFromXml(XmlNode xnod, int level)
        {
            LoadNodeFromXml(xnod, level);

            if (xnod.Name == "Geography")
            {
                locations.Clear();
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    location locn = new location();
                    locn.LoadFromXml((XmlNode)xnod.ChildNodes[i], level);
                    locations.Add(locn);
                }
            }

            if (xnod.Name == "Population")
            {
                personalities.Clear();
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    personality p = new personality();
                    p.LoadFromXml((XmlNode)xnod.ChildNodes[i], level);
                    personalities.Add(p);
                }
            }

            if (xnod.Name == "Events")
            {
                events.Clear();
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    societyevent ev = new societyevent();
                    ev.LoadFromXml((XmlNode)xnod.ChildNodes[i], level);
                    events.Add(ev);
                }
            }

            // call recursively on all children of the current node
            if (xnod.HasChildNodes)
            {
                XmlNode xnodWorking = xnod.FirstChild;
                while (xnodWorking != null)
                {
                    LoadFromXml(xnodWorking, level + 1);
                    xnodWorking = xnodWorking.NextSibling;
                }
            }
        }
Пример #3
0
        /// <summary>
        /// parse an xml node
        /// </summary>
        /// <param name="xnod"></param>
        /// <param name="level"></param>
        public void LoadFromXml(XmlNode xnod, int level)
        {
            if (xnod.Name == "Type")
                Type = xnod.InnerText;

            if (xnod.Name == "Date")
                SetStartTime(DateTime.Parse(xnod.InnerText));

            if (xnod.Name == "Description")
                Description = xnod.InnerText;

            if (xnod.Name == "Locations")
            {
                locations.Clear();
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    location locn = new location();
                    locn.LoadFromXml((XmlNode)xnod.ChildNodes[i], level);
                    locations.Add(locn);
                }
            }

            if (xnod.Name == "People")
            {
                people.Clear();
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    personality p = new personality();
                    p.LoadFromXml((XmlNode)xnod.ChildNodes[i], level);
                    people.Add(p);
                }
            }

            if (xnod.Name == "Possessions")
            {
                possessions.Clear();
                for (int i = 0; i < xnod.ChildNodes.Count; i++)
                {
                    possession p = new possession();
                    p.LoadFromXml((XmlNode)xnod.ChildNodes[i], level);
                    possessions.Add(p);
                }
            }

            // call recursively on all children of the current node
            if (xnod.HasChildNodes)
            {
                XmlNode xnodWorking = xnod.FirstChild;
                while (xnodWorking != null)
                {
                    LoadFromXml(xnodWorking, level + 1);
                    xnodWorking = xnodWorking.NextSibling;
                }
            }
        }
Пример #4
0
        /// <summary>
        /// parse an xml node
        /// </summary>
        /// <param name="xnod"></param>
        /// <param name="level"></param>
        public override void LoadFromXml(XmlNode xnod, int level)
        {
            LoadNodeFromXml(xnod, level);

            if (xnod.Name == "BelongsTo")
            {
                BelongsTo = new personality();
                BelongsTo.LoadFromXml(xnod, level);
            }

            if (xnod.Name == "Name")
                Name = xnod.InnerText;

            if (xnod.Name == "PossessionType")
                SetPossessionType(xnod.InnerText);

            if (xnod.Name == "AcquiredDate")
                SetAcquiredDate(DateTime.Parse(xnod.InnerText));

            if (xnod.Name == "notOwned")
                notOwned = Convert.ToBoolean(xnod.InnerText);

            if (xnod.Name == "RelinquishedDate")
                SetRelinquishedDate(DateTime.Parse(xnod.InnerText));

            if (xnod.Name == "AcquiredFrom")
            {
                AcquiredFrom = new personality();
                AcquiredFrom.LoadFromXml(xnod, level);
            }

            // call recursively on all children of the current node
            if (xnod.HasChildNodes)
            {
                XmlNode xnodWorking = xnod.FirstChild;
                while (xnodWorking != null)
                {
                    LoadFromXml(xnodWorking, level + 1);
                    xnodWorking = xnodWorking.NextSibling;
                }
            }
        }