Exemple #1
0
        public static Panel Create(XmlReader reader, IWidget parent = null)
        {
            Panel panel = new Panel();

            if (reader.GetAttribute("id") != null)
            {
                panel.Id = reader.GetAttribute("id");
            }
            panel.SetParent(parent);

            if (reader.GetAttribute("anchorMin") != null || reader.GetAttribute("anchorMax") != null)
            {
                Vector2 anchorMin = XmlUtilities.ToVector2(reader.GetAttribute("anchorMin"));
                Vector2 anchorMax = XmlUtilities.ToVector2(reader.GetAttribute("anchorMax"));
                panel.SetAnchor(anchorMin, anchorMax);
            }
            string layout = reader.GetAttribute("layout");

            panel.SetLayout(layout);
            switch (layout)
            {
            case "grid":
                if (reader.GetAttribute("gridX") != null)
                {
                    (panel.layout as GridLayoutGroup).constraint      = GridLayoutGroup.Constraint.FixedRowCount;
                    (panel.layout as GridLayoutGroup).constraintCount = Convert.ToInt32(reader.GetAttribute("gridX"));
                }
                else if (reader.GetAttribute("gridY") != null)
                {
                    (panel.layout as GridLayoutGroup).constraint      = GridLayoutGroup.Constraint.FixedColumnCount;
                    (panel.layout as GridLayoutGroup).constraintCount = Convert.ToInt32(reader.GetAttribute("gridY"));
                }
                break;

            case "horizontal":
                break;

            case "vertical":
                break;
            }

            switch (reader.GetAttribute("content"))
            {
            case "minFit":
                panel.AddContentSizeFitter(ContentSizeFitter.FitMode.MinSize);
                break;

            case "preferredFit":
                panel.AddContentSizeFitter(ContentSizeFitter.FitMode.PreferredSize);
                break;

            default:
                break;
            }

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    //if (reader.Name == "Text")
                    //{

                    //}
                    //else
                    //{
                    XmlReader subReader = reader.ReadSubtree();
                    GUIController.ReadElement(subReader, panel);
                    subReader.Close();
                    //}
                }
            }


            return(panel);
        }
    public void ReadXmlPrototype(XmlReader reader_parent)
    {
        ////Debug.Log("ReadXmlPrototype");

        objectType = reader_parent.GetAttribute("objectType");

        XmlReader reader = reader_parent.ReadSubtree();

        while (reader.Read())
        {
            switch (reader.Name)
            {
            case "Name":
                reader.Read();
                Name = reader.ReadContentAsString();
                break;

            case "TypeTag":
                reader.Read();
                typeTags.Add(reader.ReadContentAsString());
                break;

            case "Description":
                reader.Read();
                Description = reader.ReadContentAsString();
                break;

            case "MovementCost":
                reader.Read();
                movementCost = reader.ReadContentAsFloat();
                break;

            case "Width":
                reader.Read();
                Width = reader.ReadContentAsInt();
                break;

            case "Height":
                reader.Read();
                Height = reader.ReadContentAsInt();
                break;

            case "LinksToNeighbours":
                reader.Read();
                linksToNeighbour = reader.ReadContentAsBoolean();
                break;

            case "EnclosesRooms":
                reader.Read();
                roomEnclosure = reader.ReadContentAsBoolean();
                break;

            case "CanReplaceFurniture":
                replaceableFurniture.Add(reader.GetAttribute("typeTag").ToString());
                break;

            case "DragType":
                reader.Read();
                dragType = reader.ReadContentAsString();
                break;

            case "BuildingJob":
                float jobTime = float.Parse(reader.GetAttribute("jobTime"));

                List <Inventory> invs = new List <Inventory>();

                XmlReader invs_reader = reader.ReadSubtree();

                while (invs_reader.Read())
                {
                    if (invs_reader.Name == "Inventory")
                    {
                        // Found an inventory requirement, so add it to the list!
                        invs.Add(new Inventory(
                                     invs_reader.GetAttribute("objectType"),
                                     int.Parse(invs_reader.GetAttribute("amount")),
                                     0));
                    }
                }

                Job j = new Job(
                    null,
                    objectType,
                    FurnitureActions.JobComplete_FurnitureBuilding,
                    jobTime,
                    invs.ToArray(),
                    Job.JobPriority.High);
                j.JobDescription = "job_build_" + objectType + "_desc";
                World.current.SetFurnitureJobPrototype(j, this);
                break;

            case "Action":
                XmlReader subtree = reader.ReadSubtree();
                eventActions.ReadXml(subtree);
                subtree.Close();
                break;

            case "ContextMenuAction":
                contextMenuLuaActions.Add(new ContextMenuLuaAction
                {
                    LuaFunction = reader.GetAttribute("FunctionName"),
                    Text        = reader.GetAttribute("Text"),
                    RequiereCharacterSelected = bool.Parse(reader.GetAttribute("RequiereCharacterSelected"))
                });
                break;

            case "IsEnterable":
                isEnterableAction = reader.GetAttribute("FunctionName");
                break;

            case "GetSpriteName":
                getSpriteNameAction = reader.GetAttribute("FunctionName");
                break;

            case "JobSpotOffset":
                jobSpotOffset = new Vector2(
                    int.Parse(reader.GetAttribute("X")),
                    int.Parse(reader.GetAttribute("Y")));
                break;

            case "JobSpawnSpotOffset":
                jobSpawnSpotOffset = new Vector2(
                    int.Parse(reader.GetAttribute("X")),
                    int.Parse(reader.GetAttribute("Y")));
                break;

            case "Power":
                reader.Read();
                powerValue = reader.ReadContentAsFloat();
                //TODO: PowerRelated = new PowerRelated();
                //TODO: PowerRelated.ReadPrototype(reader);
                break;

            case "Params":
                ReadXmlParams(reader);  // Read in the Param tag
                break;

            case "LocalizationCode":
                reader.Read();
                localizationCode = reader.ReadContentAsString();
                break;

            case "UnlocalizedDescription":
                reader.Read();
                unlocalizedDescription = reader.ReadContentAsString();
                break;
            }
        }
    }
Exemple #3
0
        /// <summary>
        /// This method parses quickly without paying attention to
        /// context validation, polygon boundaries and multi-geometries.
        /// This accelerates the geometry parsing process,
        /// but in scarce cases can lead to errors.
        /// </summary>
        /// <param name="geometryType">The geometry type (Point, LineString, Polygon, MultiPoint, MultiCurve,
        /// MultiLineString (deprecated), MultiSurface, MultiPolygon (deprecated)</param>
        /// <returns>The created geometries</returns>
        internal virtual Collection <IGeometry> createQuickGeometries(string geometryType)
        {
            // Ignore multi-geometries
            if (geometryType.Equals("MultiPointPropertyType"))
            {
                geometryType = "PointPropertyType";
            }
            else if (geometryType.Equals("MultiLineStringPropertyType"))
            {
                geometryType = "LineStringPropertyType";
            }
            else if (geometryType.Equals("MultiPolygonPropertyType"))
            {
                geometryType = "PolygonPropertyType";
            }
            else if (geometryType.Equals("MultiCurvePropertyType"))
            {
                geometryType = "CurvePropertyType";
            }
            else if (geometryType.Equals("MultiSurfacePropertyType"))
            {
                geometryType = "SurfacePropertyType";
            }

            string serviceException = null;

            while (_XmlReader.Read())
            {
                if (_CoordinatesNode.Matches(_XmlReader))
                {
                    try
                    {
                        switch (geometryType)
                        {
                        case "PointPropertyType":
                            _Geoms.Add(Factory.CreatePoint(ParseCoordinates(_XmlReader.ReadSubtree())[0]));
                            break;

                        case "LineStringPropertyType":
                        case "CurvePropertyType":
                            _Geoms.Add(Factory.CreateLineString(ParseCoordinates(_XmlReader.ReadSubtree())));
                            break;

                        case "PolygonPropertyType":
                        case "SurfacePropertyType":
                            _Geoms.Add(Factory.CreatePolygon(
                                           Factory.CreateLinearRing(ParseCoordinates(_XmlReader.ReadSubtree())), null));
                            break;

                        default:
                            break;
                        }
                    }
                    catch (Exception ex)
                    {
                        Trace.TraceError("An exception occured while parsing a " + geometryType + " geometry: " +
                                         ex.Message);
                        throw ex;
                    }
                    continue;
                }

                if (_ServiceExceptionNode.Matches(_XmlReader))
                {
                    serviceException = _XmlReader.ReadInnerXml();
                    Trace.TraceError("A service exception occured: " + serviceException);
                    throw new Exception("A service exception occured: " + serviceException);
                }
            }

            return(_Geoms);
        }
Exemple #4
0
        private void ReadDsiXml(Stream stream)
        {
            using (XmlReader xReader = XmlReader.Create(stream))
            {
                while (xReader.Read())
                {
                    switch (xReader.NodeType)
                    {
                    case XmlNodeType.Element:
                        if (xReader.Name == "metadatagroup")
                        {
                            string groupName = xReader.GetAttribute("name");
                            List <KeyValuePair <string, string> > groupMetaData = new List <KeyValuePair <string, string> >();
                            _metaData.Add(new KeyValuePair <string, List <KeyValuePair <string, string> > >(groupName, groupMetaData));

                            XmlReader xMetaDataReader = xReader.ReadSubtree();
                            while (xMetaDataReader.Read())
                            {
                                if (xMetaDataReader.Name == "metadata")
                                {
                                    string name  = xMetaDataReader.GetAttribute("name");
                                    string value = xMetaDataReader.GetAttribute("value");
                                    if ((name != null) && (value != null))
                                    {
                                        groupMetaData.Add(new KeyValuePair <string, string>(name, value));
                                    }
                                }
                            }
                        }

                        if (xReader.Name == "element")
                        {
                            int id;
                            int.TryParse(xReader.GetAttribute("id"), out id);
                            string name = xReader.GetAttribute("name");
                            string type = xReader.GetAttribute("type");

                            string[] nameParts = name.Split('.');
                            if (nameParts.Length >= 2)
                            {
                                string  typeName = nameParts[nameParts.Length - 1];
                                string  path     = name.Substring(0, name.Length - typeName.Length - 1);
                                Element module   = CreateModule(typeName, path, type);
                                module.Id = id;
                                if (!_elements.ContainsKey(id))
                                {
                                    _elements.Add(id, module);
                                }
                            }
                        }
                        else if (xReader.Name == "relation")
                        {
                            int providerId;
                            int.TryParse(xReader.GetAttribute("providerId"), out providerId);

                            int consumerId;
                            int.TryParse(xReader.GetAttribute("consumerId"), out consumerId);

                            string type = xReader.GetAttribute("type");

                            int weight;
                            int.TryParse(xReader.GetAttribute("weight"), out weight);

                            Element consumer = _elements.ContainsKey(consumerId) ? _elements[consumerId] : null;
                            Element provider = _elements.ContainsKey(providerId) ? _elements[providerId] : null;
                            AddRelation(consumer, provider, type, weight, false, false);
                        }
                        break;

                    case XmlNodeType.Text:
                        break;

                    case XmlNodeType.EndElement:
                        break;
                    }
                }
            }
        }
Exemple #5
0
    public void ReadXmlPrototype(XmlReader reader_parent)
    {
        Type = reader_parent.GetAttribute("type");

        XmlReader reader = reader_parent.ReadSubtree();

        while (reader.Read())
        {
            switch (reader.Name)
            {
            case "potentialNames":
                PotentialNames = new List <string>();
                XmlReader namesReader = reader.ReadSubtree();

                while (namesReader.Read())
                {
                    if (namesReader.Name == "name")
                    {
                        PotentialNames.Add(namesReader.ReadElementContentAsString());
                    }
                }

                break;

            case "currencyName":
                reader.Read();
                CurrencyName = reader.ReadContentAsString();
                break;

            case "minCurrencyBalance":
                reader.Read();
                MinCurrencyBalance = reader.ReadContentAsInt();
                break;

            case "maxCurrencyBalance":
                reader.Read();
                MaxCurrencyBalance = reader.ReadContentAsInt();
                break;

            case "minSaleMarginMultiplier":
                reader.Read();
                MinSaleMarginMultiplier = reader.ReadContentAsFloat();
                break;

            case "maxSaleMarginMultiplier":
                reader.Read();
                MaxSaleMarginMultiplier = reader.ReadContentAsFloat();
                break;

            case "potentialStock":
                PotentialStock = new List <TraderPotentialInventory>();
                XmlReader invs_reader = reader.ReadSubtree();

                while (invs_reader.Read())
                {
                    if (invs_reader.Name == "Inventory")
                    {
                        // Found an inventory requirement, so add it to the list!
                        PotentialStock.Add(new TraderPotentialInventory
                        {
                            Type        = invs_reader.GetAttribute("type"),
                            Category    = invs_reader.GetAttribute("category"),
                            MinQuantity = int.Parse(invs_reader.GetAttribute("minQuantity")),
                            MaxQuantity = int.Parse(invs_reader.GetAttribute("maxQuantity")),
                            Rarity      = float.Parse(invs_reader.GetAttribute("rarity"))
                        });
                    }
                }

                break;

            case "Animations":
                XmlReader animationReader = reader.ReadSubtree();
                ReadAnimationXml(animationReader);
                break;
            }
        }
    }
Exemple #6
0
        /// <summary>
        /// 读取选项配置文件中的XML内容。
        /// </summary>
        /// <param name="reader">在选项配置文件中进行读取操作的<seealso cref="System.Xml.XmlReader"/>读取器。</param>
        protected internal virtual void DeserializeElement(XmlReader reader)
        {
            if (reader.ReadState == ReadState.Initial)
            {
                if (!reader.Read())
                {
                    throw new OptionConfigurationException();
                }
            }

            OptionConfigurationProperty property;

            //反序列化当前元素的Attributes到当前元素的属性集
            this.DeserializeAttributes(reader, this);

            //如果当前XML元素是空元素(即其没有子节点的元素),则返回
            if (reader.IsEmptyElement)
            {
                return;
            }

            //定义当前读取器的初始深度
            int depth = reader.Depth;

            //定义当前待解析子元素的当前配置项元素
            OptionConfigurationElement element = this;

            while (reader.Read() && reader.Depth > depth)
            {
                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }

                if (reader.Depth == depth + 1)
                {
                    element = this;
                }

                //如果当前配置项元素是配置集合,则约定当前读取器所处的位置应当处于其下的集合元素的XML节点处
                if (typeof(OptionConfigurationElementCollection).IsAssignableFrom(element.GetType()))
                {
                    //使用当前配置集合来解析当前读取器所处的XML节点内容
                    element.DeserializeElement(reader.ReadSubtree());
                    //忽略后续操作,直接进行后续XML内容处理
                    continue;
                }

                //根据当前XML元素名获取对应的配置属性定义项,如果获取失败则获取当前配置项中的默认集合属性定义项
                if (!element.Properties.TryGetValue(reader.Name, out property))
                {
                    property = OptionConfigurationUtility.GetDefaultCollectionProperty(element.Properties);
                }

                //如果对应的配置属性定义项均获取失败则抛出异常
                if (property == null)
                {
                    throw new OptionConfigurationException(string.Format("The '{0}' option configuration element is unrecognized.", reader.Name));
                }

                //获取或创建当前配置属性定义项对应的目标元素对象
                element = element.EnsureElementPropertyValue(property);
                //判断获取的配置项元素是否为配置项集合
                var collection = element as OptionConfigurationElementCollection;

                if (collection != null)
                {
                    //如果当前配置项集合不是默认集合(即集合有对应的XML节点),则将当前读取器移动到其下的子元素的XML节点上
                    if (!property.IsDefaultCollection)
                    {
                        //反序列化当前元素中的Attributes到元素属性集中
                        this.DeserializeAttributes(reader, element);

                        //将当前读取器移动到集合成员元素上
                        reader.ReadToDescendant(string.IsNullOrWhiteSpace(property.ElementName) ? collection.ElementName : property.ElementName);
                    }
                }

                //调用当前配置元素对象的反序列化方法
                element.DeserializeElement(reader.ReadSubtree());
            }
        }
Exemple #7
0
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            var userDataUserId = _config.GetNfoConfiguration().UserId;

            switch (reader.Name)
            {
            // DateCreated
            case "dateadded":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime added;
                    if (DateTime.TryParseExact(val, BaseNfoSaver.DateAddedFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out added))
                    {
                        item.EndDate = added.ToUniversalTime();
                    }
                    else if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.Warn("Invalid Added value found: " + val);
                    }
                }
                break;
            }

            case "originaltitle":
            {
                var val = reader.ReadElementContentAsString();

                var hasOriginalTitle = item as IHasOriginalTitle;
                if (hasOriginalTitle != null)
                {
                    if (!string.IsNullOrEmpty(hasOriginalTitle.OriginalTitle))
                    {
                        hasOriginalTitle.OriginalTitle = val;
                    }
                }
                break;
            }

            case "type":
                item.DisplayMediaType = reader.ReadElementContentAsString();
                break;

            case "title":
            case "localtitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "criticrating":
            {
                var text = reader.ReadElementContentAsString();

                var hasCriticRating = item as IHasCriticRating;

                if (hasCriticRating != null && !string.IsNullOrEmpty(text))
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasCriticRating.CriticRating = value;
                    }
                }

                break;
            }

            case "budget":
            {
                var text      = reader.ReadElementContentAsString();
                var hasBudget = item as IHasBudget;
                if (hasBudget != null)
                {
                    double value;
                    if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasBudget.Budget = value;
                    }
                }

                break;
            }

            case "revenue":
            {
                var text      = reader.ReadElementContentAsString();
                var hasBudget = item as IHasBudget;
                if (hasBudget != null)
                {
                    double value;
                    if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasBudget.Revenue = value;
                    }
                }

                break;
            }

            case "metascore":
            {
                var text         = reader.ReadElementContentAsString();
                var hasMetascore = item as IHasMetascore;
                if (hasMetascore != null)
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasMetascore.Metascore = value;
                    }
                }

                break;
            }

            case "awardsummary":
            {
                var text      = reader.ReadElementContentAsString();
                var hasAwards = item as IHasAwards;
                if (hasAwards != null)
                {
                    if (!string.IsNullOrWhiteSpace(text))
                    {
                        hasAwards.AwardSummary = text;
                    }
                }

                break;
            }

            case "sorttitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }
                break;
            }

            case "outline":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasShortOverview = item as IHasShortOverview;

                    if (hasShortOverview != null)
                    {
                        hasShortOverview.ShortOverview = val;
                    }
                }
                break;
            }

            case "biography":
            case "plot":
            case "review":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "criticratingsummary":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasCriticRating = item as IHasCriticRating;

                    if (hasCriticRating != null)
                    {
                        hasCriticRating.CriticRatingSummary = val;
                    }
                }

                break;
            }

            case "language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "countrycode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "website":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.HomePageUrl = val;
                }

                break;
            }

            case "lockedfields":
            {
                var fields = new List <MetadataFields>();

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var list = val.Split('|').Select(i =>
                        {
                            MetadataFields field;

                            if (Enum.TryParse <MetadataFields>(i, true, out field))
                            {
                                return((MetadataFields?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i.Value);

                    fields.AddRange(list);
                }

                item.LockedFields = fields;

                break;
            }

            case "tagline":
            {
                var val = reader.ReadElementContentAsString();

                var hasTagline = item as IHasTaglines;
                if (hasTagline != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasTagline.AddTagline(val);
                    }
                }
                break;
            }

            case "country":
            {
                var val = reader.ReadElementContentAsString();

                var hasProductionLocations = item as IHasProductionLocations;
                if (hasProductionLocations != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        var parts = val.Split('/')
                                    .Select(i => i.Trim())
                                    .Where(i => !string.IsNullOrWhiteSpace(i));

                        foreach (var p in parts)
                        {
                            hasProductionLocations.AddProductionLocation(p);
                        }
                    }
                }
                break;
            }

            case "mpaa":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }
                break;
            }

            case "mpaadescription":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRatingDescription = rating;
                }
                break;
            }

            case "customrating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }
                break;
            }

            case "runtime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    int runtime;
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }
                break;
            }

            case "aspectratio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }
                break;
            }

            case "lockdata":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }
                break;
            }

            case "studio":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/')
                                .Select(i => i.Trim())
                                .Where(i => !string.IsNullOrWhiteSpace(i));

                    foreach (var p in parts)
                    {
                        item.AddStudio(p);
                    }
                }
                break;
            }

            case "director":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "credits":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/').Select(i => i.Trim())
                                .Where(i => !string.IsNullOrEmpty(i));

                    foreach (var p in parts.Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Writer
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }
                        itemResult.AddPerson(p);
                    }
                }
                break;
            }

            case "writer":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "actor":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    var person = GetPersonFromXmlNode(subtree);

                    if (!string.IsNullOrWhiteSpace(person.Name))
                    {
                        itemResult.AddPerson(person);
                    }
                }
                break;
            }

            case "trailer":
            {
                var val = reader.ReadElementContentAsString();

                var hasTrailer = item as IHasTrailers;
                if (hasTrailer != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        val = val.Replace("plugin://plugin.video.youtube/?action=play_video&videoid=", "http://www.youtube.com/watch?v=", StringComparison.OrdinalIgnoreCase);

                        hasTrailer.AddTrailerUrl(val, false);
                    }
                }
                break;
            }

            case "displayorder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }
                break;
            }

            case "year":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int productionYear;
                    if (int.TryParse(val, out productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "rating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    float val;
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out val))
                    {
                        item.CommunityRating = val;
                    }
                }
                break;
            }

            case "aired":
            case "formed":
            case "premiered":
            case "releasedate":
            {
                var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime date;

                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
                    {
                        item.PremiereDate   = date.ToUniversalTime();
                        item.ProductionYear = date.Year;
                    }
                }

                break;
            }

            case "enddate":
            {
                var formatString = _config.GetNfoConfiguration().ReleaseDateFormat;

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime date;

                    if (DateTime.TryParseExact(val, formatString, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date) && date.Year > 1850)
                    {
                        item.EndDate = date.ToUniversalTime();
                    }
                }

                break;
            }

            case "tvdbid":
                var tvdbId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tvdbId))
                {
                    item.SetProviderId(MetadataProviders.Tvdb, tvdbId);
                }
                break;

            case "votes":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    int num;

                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
                    {
                        item.VoteCount = num;
                    }
                }
                break;
            }

            case "musicbrainzalbumid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzAlbum, mbz);
                }
                break;
            }

            case "musicbrainzalbumartistid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, mbz);
                }
                break;
            }

            case "musicbrainzartistid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzArtist, mbz);
                }
                break;
            }

            case "musicbrainzreleasegroupid":
            {
                var mbz = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(mbz))
                {
                    item.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, mbz);
                }
                break;
            }

            case "tvrageid":
            {
                var id = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(MetadataProviders.TvRage, id);
                }
                break;
            }

            case "audiodbartistid":
            {
                var id = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(MetadataProviders.AudioDbArtist, id);
                }
                break;
            }

            case "audiodbalbumid":
            {
                var id = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(id))
                {
                    item.SetProviderId(MetadataProviders.AudioDbAlbum, id);
                }
                break;
            }

            case "rottentomatoesid":
                var rtId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(rtId))
                {
                    item.SetProviderId(MetadataProviders.RottenTomatoes, rtId);
                }
                break;

            case "tmdbid":
                var tmdb = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdb))
                {
                    item.SetProviderId(MetadataProviders.Tmdb, tmdb);
                }
                break;

            case "collectionnumber":
            case "tmdbcolid":
                var tmdbCollection = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdbCollection))
                {
                    item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
                }
                break;

            case "tvcomid":
                var TVcomId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(TVcomId))
                {
                    item.SetProviderId(MetadataProviders.Tvcom, TVcomId);
                }
                break;

            case "zap2itid":
                var zap2ItId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(zap2ItId))
                {
                    item.SetProviderId(MetadataProviders.Zap2It, zap2ItId);
                }
                break;

            case "imdb_id":
            case "imdbid":
                var imDbId = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(imDbId))
                {
                    item.SetProviderId(MetadataProviders.Imdb, imDbId);
                }
                break;

            case "genre":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var parts = val.Split('/')
                                .Select(i => i.Trim())
                                .Where(i => !string.IsNullOrWhiteSpace(i));

                    foreach (var p in parts)
                    {
                        item.AddGenre(p);
                    }
                }
                break;
            }

            case "style":
            case "tag":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasTags = item as IHasTags;
                    if (hasTags != null)
                    {
                        hasTags.AddTag(val);
                    }
                }
                break;
            }

            case "plotkeyword":
            {
                var val = reader.ReadElementContentAsString();

                var hasKeywords = item as IHasKeywords;
                if (hasKeywords != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasKeywords.AddKeyword(val);
                    }
                }
                break;
            }

            case "fileinfo":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromFileInfoNode(subtree, item);
                }
                break;
            }

            case "watched":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    bool parsedValue;
                    if (bool.TryParse(val, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.Played = parsedValue;
                    }
                }
                break;
            }

            case "playcount":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    int parsedValue;
                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.PlayCount = parsedValue;

                        if (parsedValue > 0)
                        {
                            userData.Played = true;
                        }
                    }
                }
                break;
            }

            case "lastplayed":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    DateTime parsedValue;
                    if (DateTime.TryParseExact(val, "yyyy-MM-dd HH:mm:ss", _usCulture, DateTimeStyles.AssumeLocal, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.LastPlayedDate = parsedValue.ToUniversalTime();
                    }
                }
                break;
            }

            case "resume":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    if (!string.IsNullOrWhiteSpace(userDataUserId))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        FetchFromResumeNode(subtree, item, userData);
                    }
                }
                break;
            }

            case "isuserfavorite":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    bool parsedValue;
                    if (bool.TryParse(val, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.IsFavorite = parsedValue;
                    }
                }
                break;
            }

            case "userrating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val) && !string.IsNullOrWhiteSpace(userDataUserId))
                {
                    double parsedValue;
                    if (double.TryParse(val, NumberStyles.Any, _usCulture, out parsedValue))
                    {
                        var userData = GetOrAdd(itemResult, userDataUserId);

                        userData.Rating = parsedValue;
                    }
                }
                break;
            }

            default:
                reader.Skip();
                break;
            }
        }
        internal static ObjectGroup Load(XmlReader reader)
        {
            var         result = new ObjectGroup();
            CultureInfo ci     = (CultureInfo)CultureInfo.CurrentCulture.Clone();

            ci.NumberFormat.CurrencyDecimalSeparator = ".";

            if (reader.GetAttribute("name") != null)
            {
                result.Name = reader.GetAttribute("name");
            }
            if (reader.GetAttribute("width") != null)
            {
                result.Width = int.Parse(reader.GetAttribute("width"));
            }
            if (reader.GetAttribute("height") != null)
            {
                result.Height = int.Parse(reader.GetAttribute("height"));
            }
            if (reader.GetAttribute("x") != null)
            {
                result.X = int.Parse(reader.GetAttribute("x"));
            }
            if (reader.GetAttribute("y") != null)
            {
                result.Y = int.Parse(reader.GetAttribute("y"));
            }
            if (reader.GetAttribute("opacity") != null)
            {
                result.Opacity = float.Parse(reader.GetAttribute("opacity"), NumberStyles.Any, ci);
            }

            while (!reader.EOF)
            {
                var name = reader.Name;

                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                    switch (name)
                    {
                    case "object":
                    {
                        using (var st = reader.ReadSubtree())
                        {
                            st.Read();
                            var objects = Object.Load(st);
                            if (!result.Objects.ContainsKey(objects.Name))
                            {
                                result.Objects.Add(objects.Name, objects);
                            }
                            else
                            {
                                //!!!int count = result.Objects.Keys.Count((item) => item.Equals(objects.Name));
                                int count = result.Objects.Keys.Count;
                                result.Objects.Add(string.Format("{0}{1}", objects.Name, count), objects);
                            }
                        }
                    }
                    break;

                    case "properties":
                    {
                        using (var st = reader.ReadSubtree())
                        {
                            while (!st.EOF)
                            {
                                switch (st.NodeType)
                                {
                                case XmlNodeType.Element:
                                    if (st.Name == "property")
                                    {
                                        if (st.GetAttribute("name") != null)
                                        {
                                            result.Properties.Add(st.GetAttribute("name"), st.GetAttribute("value"));
                                        }
                                    }

                                    break;

                                case XmlNodeType.EndElement:
                                    break;
                                }

                                st.Read();
                            }
                        }
                    }
                    break;
                    }

                    break;

                case XmlNodeType.EndElement:
                    break;
                }

                reader.Read();
            }

            return(result);
        }
        internal static Object Load(XmlReader reader)
        {
            var result = new Object()
            {
                Name = reader.GetAttribute("name"),
                X    = int.Parse(reader.GetAttribute("x")),
                Y    = int.Parse(reader.GetAttribute("y"))
            };

            /*
             * Height and width are optional on objects
             */
            if (int.TryParse(reader.GetAttribute("width"), out int width))
            {
                result.Width = width;
            }

            if (int.TryParse(reader.GetAttribute("height"), out int height))
            {
                result.Height = height;
            }

            while (!reader.EOF)
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                    if (reader.Name == "properties")
                    {
                        using (var st = reader.ReadSubtree())
                        {
                            while (!st.EOF)
                            {
                                switch (st.NodeType)
                                {
                                case XmlNodeType.Element:
                                    if (st.Name == "property")
                                    {
                                        if (st.GetAttribute("name") != null)
                                        {
                                            result.Properties.Add(st.GetAttribute("name"), st.GetAttribute("value"));
                                        }
                                    }

                                    break;

                                case XmlNodeType.EndElement:
                                    break;
                                }

                                st.Read();
                            }
                        }
                    }
                    if (reader.Name == "image")
                    {
                        result.Image = reader.GetAttribute("source");
                    }
                    if (reader.Name == "polyline")
                    {
                        result.Points = reader.GetAttribute("points");
                    }

                    break;

                case XmlNodeType.EndElement:
                    break;
                }

                reader.Read();
            }

            return(result);
        }
Exemple #10
0
        /// <summary>
        /// Write an object.
        /// </summary>
        private void WriteObject(AmfContext context, AmfStreamWriter writer, XmlReader input)
        {
            context.References.Add(new AmfReference {
                AmfxType = AmfxContent.Object
            });
            WriteTypeMarker(writer, Amf3TypeMarker.Object);

            AmfTypeTraits traits;
            var           typeName = string.Empty;

            if (input.HasAttributes)
            {
                typeName = input.GetAttribute(AmfxContent.ObjectType);
            }

            #region Write traits
            input.Read();

            //Send traits by value
            if (!input.IsEmptyElement)
            {
                traits = new AmfTypeTraits {
                    TypeName = typeName
                };
                context.TraitsReferences.Add(traits);

                var traitsReader = input.ReadSubtree();
                traitsReader.MoveToContent();
                traitsReader.ReadStartElement();

                var members = new List <string>();

                while (input.NodeType != XmlNodeType.EndElement)
                {
                    members.Add(traitsReader.ReadElementContentAsString());
                }

                traits.ClassMembers = members.ToArray();

                //The first bit is a flag with value 1.
                //The second bit is a flag with value 1.
                //The third bit is a flag with value 0.
                var flag = 0x3; //00000011

                if (traits.IsExternalizable)
                {
                    flag |= 0x4;                          //00000111
                }
                //The fourth bit is a flag specifying whether the type is dynamic.
                //A value of 0 implies not dynamic, a value of 1 implies dynamic.
                if (traits.IsDynamic)
                {
                    flag |= 0x8;                   //00001011
                }
                //The remaining 1 to 25 significant bits are used to encode the number
                //of sealed traits member names that follow after the class name.
                var count = traits.ClassMembers.Count();
                flag |= count << 4;

                WriteUInt29(writer, flag);

                WriteUtf8(context, writer, traits.TypeName);

                //Write member names
                foreach (var member in traits.ClassMembers)
                {
                    WriteUtf8(context, writer, member);
                }
            }
            //Send traits by reference
            else
            {
                var index = Convert.ToInt32(input.GetAttribute(AmfxContent.TraitsId), CultureInfo.InvariantCulture);
                traits = context.TraitsReferences[index];

                var flag = index & UInt29Mask; //Truncate value to UInt29

                //The first bit is a flag with value 1.
                //The second bit is a flag (representing whether a trait
                //reference follows) with value 0 to imply that this objects
                //traits are being sent by reference. The remaining 1 to 27
                //significant bits are used to encode a trait reference index.
                flag = (flag << 2) | 0x1;
                WriteUInt29(writer, flag);
            }

            input.Read();
            #endregion

            #region Write members
            for (var i = 0; i < traits.ClassMembers.Length; i++)
            {
                WriteAmfValue(context, input, writer);
                input.Read();
            }
            #endregion
        }
        internal static Layer Load(XmlReader reader)
        {
            CultureInfo ci = (CultureInfo)CultureInfo.CurrentCulture.Clone();

            ci.NumberFormat.CurrencyDecimalSeparator = ".";
            var result = new Layer();

            if (reader.GetAttribute("name") != null)
            {
                result.Name = reader.GetAttribute("name");
            }
            if (reader.GetAttribute("width") != null)
            {
                result.Width = int.Parse(reader.GetAttribute("width"));
            }
            if (reader.GetAttribute("height") != null)
            {
                result.Height = int.Parse(reader.GetAttribute("height"));
            }
            if (reader.GetAttribute("opacity") != null)
            {
                result.Opacity = float.Parse(reader.GetAttribute("opacity"), NumberStyles.Any, ci);
            }
            result.Tiles         = new int[result.Width * result.Height];
            result.FlipAndRotate = new byte[result.Width * result.Height];

            while (!reader.EOF)
            {
                var name = reader.Name;

                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                    switch (name)
                    {
                    case "data":
                    {
                        if (reader.GetAttribute("encoding") != null)
                        {
                            var encoding   = reader.GetAttribute("encoding");
                            var compressor = reader.GetAttribute("compression");
                            switch (encoding)
                            {
                            case "base64":
                            {
                                int dataSize = (result.Width * result.Height * 4) + 1024;
                                var buffer   = new byte[dataSize];
                                reader.ReadElementContentAsBase64(buffer, 0, dataSize);

                                Stream stream = new MemoryStream(buffer, false);
                                if (compressor == "gzip")
                                {
                                    stream = new GZipStream(stream, CompressionMode.Decompress, false);
                                }

                                using (stream)
                                    using (var br = new BinaryReader(stream))
                                    {
                                        for (int i = 0; i < result.Tiles.Length; i++)
                                        {
                                            uint tileData = br.ReadUInt32();

                                            // The data contain flip information as well as the tileset index
                                            byte flipAndRotateFlags = 0;
                                            if ((tileData & FlippedHorizontallyFlag) != 0)
                                            {
                                                flipAndRotateFlags |= HorizontalFlipDrawFlag;
                                            }
                                            if ((tileData & FlippedVerticallyFlag) != 0)
                                            {
                                                flipAndRotateFlags |= VerticalFlipDrawFlag;
                                            }
                                            if ((tileData & FlippedDiagonallyFlag) != 0)
                                            {
                                                flipAndRotateFlags |= DiagonallyFlipDrawFlag;
                                            }
                                            result.FlipAndRotate[i] = flipAndRotateFlags;

                                            // Clear the flip bits before storing the tile data
                                            tileData &= ~(FlippedHorizontallyFlag |
                                                          FlippedVerticallyFlag |
                                                          FlippedDiagonallyFlag);
                                            result.Tiles[i] = (int)tileData;
                                        }
                                    }

                                continue;
                            };

                            default:
                                throw new Exception("Unrecognized encoding.");
                            }
                        }
                        else
                        {
                            using (var st = reader.ReadSubtree())
                            {
                                int i = 0;
                                while (!st.EOF)
                                {
                                    switch (st.NodeType)
                                    {
                                    case XmlNodeType.Element:
                                        if (st.Name == "tile")
                                        {
                                            if (i < result.Tiles.Length)
                                            {
                                                result.Tiles[i] = int.Parse(st.GetAttribute("gid"));
                                                i++;
                                            }
                                        }

                                        break;

                                    case XmlNodeType.EndElement:
                                        break;
                                    }

                                    st.Read();
                                }
                            }
                        }
                        Console.WriteLine("It made it!");
                    }
                    break;

                    case "properties":
                    {
                        using (var st = reader.ReadSubtree())
                        {
                            while (!st.EOF)
                            {
                                switch (st.NodeType)
                                {
                                case XmlNodeType.Element:
                                    if (st.Name == "property")
                                    {
                                        if (st.GetAttribute("name") != null)
                                        {
                                            result.Properties.Add(st.GetAttribute("name"), st.GetAttribute("value"));
                                        }
                                    }

                                    break;

                                case XmlNodeType.EndElement:
                                    break;
                                }

                                st.Read();
                            }
                        }
                    }
                    break;
                    }

                    break;

                case XmlNodeType.EndElement:
                    break;
                }

                reader.Read();
            }

            return(result);
        }
Exemple #12
0
        /// <summary>
        /// Fetches metadata from one Xml Element.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="itemResult">The item result.</param>
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            switch (reader.Name)
            {
            // DateCreated
            case "Added":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (DateTime.TryParse(val, out var added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.LogWarning("Invalid Added value found: " + val);
                    }
                }

                break;
            }

            case "OriginalTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(val))
                {
                    item.OriginalTitle = val;
                }

                break;
            }

            case "LocalTitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "CriticRating":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrEmpty(text))
                {
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out var value))
                    {
                        item.CriticRating = value;
                    }
                }

                break;
            }

            case "SortTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }

                break;
            }

            case "Overview":
            case "Description":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "Language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "CountryCode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "PlaceOfBirth":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (item is Person person)
                    {
                        person.ProductionLocations = new[] { val };
                    }
                }

                break;
            }

            case "LockedFields":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.LockedFields = val.Split('|').Select(i =>
                        {
                            if (Enum.TryParse(i, true, out MetadataField field))
                            {
                                return((MetadataField?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i !.Value).ToArray();
                }

                break;
            }

            case "TagLines":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromTaglinesNode(subtree, item);
                    }
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "Countries":
            {
                if (!reader.IsEmptyElement)
                {
                    using (var subtree = reader.ReadSubtree())
                    {
                        FetchFromCountriesNode(subtree);
                    }
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "ContentRating":
            case "MPAARating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }

                break;
            }

            case "CustomRating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }

                break;
            }

            case "RunningTime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out var runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }

                break;
            }

            case "AspectRatio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }

                break;
            }

            case "LockData":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }

                break;
            }

            case "Network":
            {
                foreach (var name in SplitNames(reader.ReadElementContentAsString()))
                {
                    if (string.IsNullOrWhiteSpace(name))
                    {
                        continue;
                    }

                    item.AddStudio(name);
                }

                break;
            }

            case "Director":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }

                    itemResult.AddPerson(p);
                }

                break;
            }

            case "Writer":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }

                    itemResult.AddPerson(p);
                }

                break;
            }

            case "Actors":
            {
                var actors = reader.ReadInnerXml();

                if (actors.Contains("<", StringComparison.Ordinal))
                {
                    // This is one of the mis-named "Actors" full nodes created by MB2
                    // Create a reader and pass it to the persons node processor
                    using var xmlReader = XmlReader.Create(new StringReader($"<Persons>{actors}</Persons>"));
                    FetchDataFromPersonsNode(xmlReader, itemResult);
                }
                else
                {
                    // Old-style piped string
                    foreach (var p in SplitNames(actors).Select(v => new PersonInfo {
                            Name = v.Trim(), Type = PersonType.Actor
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }

                        itemResult.AddPerson(p);
                    }
                }

                break;
            }

            case "GuestStars":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo {
                        Name = v.Trim(), Type = PersonType.GuestStar
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }

                    itemResult.AddPerson(p);
                }

                break;
            }

            case "Trailer":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.AddTrailerUrl(val);
                }

                break;
            }

            case "DisplayOrder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }

                break;
            }

            case "Trailers":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    FetchDataFromTrailersNode(subtree, item);
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "ProductionYear":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    if (int.TryParse(val, out var productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "Rating":
            case "IMDBrating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
                    {
                        item.CommunityRating = val;
                    }
                }

                break;
            }

            case "BirthDate":
            case "PremiereDate":
            case "FirstAired":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
                    {
                        item.PremiereDate   = airDate.ToUniversalTime();
                        item.ProductionYear = airDate.Year;
                    }
                }

                break;
            }

            case "DeathDate":
            case "EndDate":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
                    {
                        item.EndDate = airDate.ToUniversalTime();
                    }
                }

                break;
            }

            case "CollectionNumber":
                var tmdbCollection = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdbCollection))
                {
                    item.SetProviderId(MetadataProvider.TmdbCollection, tmdbCollection);
                }

                break;

            case "Genres":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    FetchFromGenresNode(subtree, item);
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "Tags":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    FetchFromTagsNode(subtree, item);
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "Persons":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    FetchDataFromPersonsNode(subtree, itemResult);
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "Studios":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    FetchFromStudiosNode(subtree, item);
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "Shares":
            {
                if (!reader.IsEmptyElement)
                {
                    using var subtree = reader.ReadSubtree();
                    if (item is IHasShares hasShares)
                    {
                        FetchFromSharesNode(subtree, hasShares);
                    }
                }
                else
                {
                    reader.Read();
                }

                break;
            }

            case "Format3D":
            {
                var val = reader.ReadElementContentAsString();

                if (item is Video video)
                {
                    if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.HalfSideBySide;
                    }
                    else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
                    }
                    else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.FullTopAndBottom;
                    }
                    else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.FullSideBySide;
                    }
                    else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.MVC;
                    }
                }

                break;
            }

            default:
            {
                string readerName = reader.Name;
                if (_validProviderIds !.TryGetValue(readerName, out string providerIdValue))
                {
                    var id = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(id))
                    {
                        item.SetProviderId(providerIdValue, id);
                    }
                }
Exemple #13
0
 public override XmlReader ReadSubtree()
 {
     return(_innerReader.ReadSubtree());
 }
        public static analysis Results(string xmlfile)
        {
            analysis answer = new analysis();

            using (XmlReader reader = XmlReader.Create(xmlfile))
            {
                while (!reader.EOF)
                {
                    if (reader.ReadToFollowing("header"))
                    {
                        var subtree = reader.ReadSubtree();

                        while (subtree.Read())
                        {
                            subtree.MoveToElement();
                            if (subtree.IsStartElement())
                            {
                                try
                                {
                                    switch (subtree.Name.ToLower())
                                    {
                                    case "logfile":
                                        answer.logfile = subtree.ReadString();
                                        break;

                                    case "sizekb":
                                        answer.sizekb = subtree.ReadString();
                                        break;

                                    case "sizelines":
                                        answer.sizelines = subtree.ReadString();
                                        break;

                                    case "duration":
                                        answer.duration = subtree.ReadString();
                                        break;

                                    case "vehicletype":
                                        answer.vehicletype = subtree.ReadString();
                                        break;

                                    case "firmwareversion":
                                        answer.firmwareversion = subtree.ReadString();
                                        break;

                                    case "firmwarehash":
                                        answer.firmwarehash = subtree.ReadString();
                                        break;

                                    case "hardwaretype":
                                        answer.hardwaretype = subtree.ReadString();
                                        break;

                                    case "freemem":
                                        answer.freemem = subtree.ReadString();
                                        break;

                                    case "skippedlines":
                                        answer.skippedlines = subtree.ReadString();
                                        break;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    log.Error(ex);
                                }
                            }
                        }
                    }
                    // params - later
                    if (reader.ReadToFollowing("results"))
                    {
                        var subtree = reader.ReadSubtree();

                        result res = null;

                        while (subtree.Read())
                        {
                            subtree.MoveToElement();
                            if (subtree.IsStartElement())
                            {
                                switch (subtree.Name.ToLower())
                                {
                                case "result":
                                    if (res != null && res.name != "")
                                    {
                                        answer.results.Add(res);
                                    }
                                    res = new result();
                                    break;

                                case "name":
                                    res.name = subtree.ReadString();
                                    break;

                                case "status":
                                    res.status = subtree.ReadString();
                                    break;

                                case "message":
                                    res.message = subtree.ReadString();
                                    break;

                                case "data":
                                    res.data = subtree.ReadString();
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            return(answer);
        }
Exemple #15
0
        /// <summary>
        /// Parse an SofwareList XML DAT and return all found games and roms within
        /// </summary>
        /// <param name="filename">Name of the file to be parsed</param>
        /// <param name="indexId">Index ID for the DAT</param>
        /// <param name="keep">True if full pathnames are to be kept, false otherwise (default)</param>
        /// <param name="throwOnError">True if the error that is thrown should be thrown back to the caller, false otherwise</param>
        protected override void ParseFile(string filename, int indexId, bool keep, bool throwOnError = false)
        {
            // Prepare all internal variables
            XmlReader xtr = filename.GetXmlTextReader();

            // If we got a null reader, just return
            if (xtr == null)
            {
                return;
            }

            // Otherwise, read the file to the end
            try
            {
                xtr.MoveToContent();
                while (!xtr.EOF)
                {
                    // We only want elements
                    if (xtr.NodeType != XmlNodeType.Element)
                    {
                        xtr.Read();
                        continue;
                    }

                    switch (xtr.Name)
                    {
                    case "softwarelist":
                        Header.Name        = Header.Name ?? xtr.GetAttribute("name") ?? string.Empty;
                        Header.Description = Header.Description ?? xtr.GetAttribute("description") ?? string.Empty;

                        xtr.Read();
                        break;

                    // We want to process the entire subtree of the machine
                    case "software":
                        ReadSoftware(xtr.ReadSubtree(), filename, indexId);

                        // Skip the software now that we've processed it
                        xtr.Skip();
                        break;

                    default:
                        xtr.Read();
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Warning(ex, $"Exception found while parsing '{filename}'");
                if (throwOnError)
                {
                    xtr.Dispose();
                    throw ex;
                }

                // For XML errors, just skip the affected node
                xtr?.Read();
            }

            xtr.Dispose();
        }
Exemple #16
0
        /// <summary>
        /// Fetches the data from XML node.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="result">The result.</param>
        protected override void FetchDataFromXmlNode(XmlReader reader, MetadataResult <Episode> result)
        {
            var item = result.Item;

            switch (reader.Name)
            {
            case "Episode":

                //MB generated metadata is within an "Episode" node
                using (var subTree = reader.ReadSubtree())
                {
                    subTree.MoveToContent();

                    // Loop through each element
                    while (subTree.Read())
                    {
                        if (subTree.NodeType == XmlNodeType.Element)
                        {
                            FetchDataFromXmlNode(subTree, result);
                        }
                    }
                }
                break;

            case "filename":
            {
                var filename = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(filename))
                {
                    // Strip off everything but the filename. Some metadata tools like MetaBrowser v1.0 will have an 'episodes' prefix
                    // even though it's actually using the metadata folder.
                    filename = Path.GetFileName(filename);

                    var parentFolder = Path.GetDirectoryName(_xmlPath);
                    filename = Path.Combine(parentFolder, filename);
                    var file = _fileSystem.GetFileInfo(filename);

                    if (file.Exists)
                    {
                        _imagesFound.Add(new LocalImageInfo
                            {
                                Type     = ImageType.Primary,
                                FileInfo = file
                            });
                    }
                }
                break;
            }

            case "SeasonNumber":
            {
                var number = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(number))
                {
                    int num;

                    if (int.TryParse(number, out num))
                    {
                        item.ParentIndexNumber = num;
                    }
                }
                break;
            }

            case "EpisodeNumber":
            {
                var number = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(number))
                {
                    int num;

                    if (int.TryParse(number, out num))
                    {
                        item.IndexNumber = num;
                    }
                }
                break;
            }

            case "EpisodeNumberEnd":
            {
                var number = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(number))
                {
                    int num;

                    if (int.TryParse(number, out num))
                    {
                        item.IndexNumberEnd = num;
                    }
                }
                break;
            }

            case "absolute_number":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int rval;

                    // int.TryParse is local aware, so it can be probamatic, force us culture
                    if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
                    {
                        item.AbsoluteEpisodeNumber = rval;
                    }
                }

                break;
            }

            case "DVD_episodenumber":
            {
                var number = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(number))
                {
                    float num;

                    if (float.TryParse(number, NumberStyles.Any, UsCulture, out num))
                    {
                        item.DvdEpisodeNumber = num;
                    }
                }
                break;
            }

            case "DVD_season":
            {
                var number = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(number))
                {
                    float num;

                    if (float.TryParse(number, NumberStyles.Any, UsCulture, out num))
                    {
                        item.DvdSeasonNumber = Convert.ToInt32(num);
                    }
                }
                break;
            }

            case "airsbefore_episode":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int rval;

                    // int.TryParse is local aware, so it can be probamatic, force us culture
                    if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
                    {
                        item.AirsBeforeEpisodeNumber = rval;
                    }
                }

                break;
            }

            case "airsafter_season":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int rval;

                    // int.TryParse is local aware, so it can be probamatic, force us culture
                    if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
                    {
                        item.AirsAfterSeasonNumber = rval;
                    }
                }

                break;
            }

            case "airsbefore_season":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int rval;

                    // int.TryParse is local aware, so it can be probamatic, force us culture
                    if (int.TryParse(val, NumberStyles.Integer, UsCulture, out rval))
                    {
                        item.AirsBeforeSeasonNumber = rval;
                    }
                }

                break;
            }

            case "EpisodeName":
            {
                var name = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(name))
                {
                    item.Name = name;
                }
                break;
            }


            default:
                base.FetchDataFromXmlNode(reader, result);
                break;
            }
        }
Exemple #17
0
    /// <summary>
    /// Reads the prototype utility from XML.
    /// </summary>
    /// <param name="readerParent">The XML reader to read from.</param>
    public void ReadXmlPrototype(XmlReader readerParent)
    {
        Type = readerParent.GetAttribute("type");

        XmlReader reader = readerParent.ReadSubtree();

        while (reader.Read())
        {
            switch (reader.Name)
            {
            case "Name":
                reader.Read();
                Name = reader.ReadContentAsString();
                break;

            case "TypeTag":
                reader.Read();
                typeTags.Add(reader.ReadContentAsString());
                break;

            case "Description":
                reader.Read();
                description = reader.ReadContentAsString();
                break;

            case "BuildingJob":
                ReadXmlBuildingJob(reader);
                break;

            case "DeconstructJob":
                ReadXmlDeconstructJob(reader);
                break;

            case "CanBeBuiltOn":
                tileTypeBuildPermissions.Add(reader.GetAttribute("tileType"));
                break;

            case "Action":
                XmlReader subtree = reader.ReadSubtree();
                EventActions.ReadXml(subtree);
                subtree.Close();
                break;

            case "ContextMenuAction":
                contextMenuLuaActions.Add(new ContextMenuLuaAction
                {
                    LuaFunction              = reader.GetAttribute("FunctionName"),
                    LocalizationKey          = reader.GetAttribute("Text"),
                    RequireCharacterSelected = bool.Parse(reader.GetAttribute("RequireCharacterSelected")),
                    DevModeOnly              = bool.Parse(reader.GetAttribute("DevModeOnly") ?? "false")
                });
                break;

            case "GetSpriteName":
                getSpriteNameAction = reader.GetAttribute("FunctionName");
                break;

            case "Params":
                ReadXmlParams(reader);      // Read in the Param tag
                break;

            case "LocalizationCode":
                reader.Read();
                LocalizationCode = reader.ReadContentAsString();
                break;

            case "UnlocalizedDescription":
                reader.Read();
                UnlocalizedDescription = reader.ReadContentAsString();
                break;
            }
        }
    }
Exemple #18
0
 private void Foo(XmlReader reader)
 {
     reader.Read();
     Bar(reader.ReadSubtree());
 }
Exemple #19
0
        /// <summary>
        /// Convert the parameter xml to TestSettings
        /// </summary>
        /// <param name="reader">Reader to load the settings from.</param>
        /// <returns>An instance of the <see cref="MSTestSettings"/> class</returns>
        private static MSTestSettings ToSettings(XmlReader reader)
        {
            ValidateArg.NotNull <XmlReader>(reader, "reader");

            // Expected format of the xml is: -
            //
            // <MSTestV2>
            //     <CaptureTraceOutput>true</CaptureTraceOutput>
            //     <MapInconclusiveToFailed>false</MapInconclusiveToFailed>
            //     <MapNotRunnableToFailed>false</MapNotRunnableToFailed>
            //     <EnableBaseClassTestMethodsFromOtherAssemblies>false</EnableBaseClassTestMethodsFromOtherAssemblies>
            //     <TestTimeout>5000</TestTimeout>
            //     <TreatClassAndAssemblyCleanupWarningsAsErrors>false</TreatClassAndAssemblyCleanupWarningsAsErrors>
            //     <Parallelize>
            //        <Workers>4</Workers>
            //        <Scope>TestClass</Scope>
            //     </Parallelize>
            // </MSTestV2>
            //
            // (or)
            //
            // <MSTest>
            //     <ForcedLegacyMode>true</ForcedLegacyMode>
            //     <SettingsFile>..\..\Local.testsettings</SettingsFile>
            //     <CaptureTraceOutput>true</CaptureTraceOutput>
            // </MSTest>
            MSTestSettings settings = new MSTestSettings();

            // Read the first element in the section which is either "MSTest"/"MSTestV2"
            reader.ReadToNextElement();

            if (!reader.IsEmptyElement)
            {
                reader.Read();

                while (reader.NodeType == XmlNodeType.Element)
                {
                    bool   result;
                    string elementName = reader.Name.ToUpperInvariant();
                    switch (elementName)
                    {
                    case "CAPTURETRACEOUTPUT":
                    {
                        if (bool.TryParse(reader.ReadInnerXml(), out result))
                        {
                            settings.CaptureDebugTraces = result;
                        }

                        break;
                    }

                    case "ENABLEBASECLASSTESTMETHODSFROMOTHERASSEMBLIES":
                    {
                        if (bool.TryParse(reader.ReadInnerXml(), out result))
                        {
                            settings.EnableBaseClassTestMethodsFromOtherAssemblies = result;
                        }

                        break;
                    }

                    case "FORCEDLEGACYMODE":
                    {
                        if (bool.TryParse(reader.ReadInnerXml(), out result))
                        {
                            settings.ForcedLegacyMode = result;
                        }

                        break;
                    }

                    case "MAPINCONCLUSIVETOFAILED":
                    {
                        if (bool.TryParse(reader.ReadInnerXml(), out result))
                        {
                            settings.MapInconclusiveToFailed = result;
                        }

                        break;
                    }

                    case "MAPNOTRUNNABLETOFAILED":
                    {
                        if (bool.TryParse(reader.ReadInnerXml(), out result))
                        {
                            settings.MapNotRunnableToFailed = result;
                        }

                        break;
                    }

                    case "SETTINGSFILE":
                    {
                        string fileName = reader.ReadInnerXml();

                        if (!string.IsNullOrEmpty(fileName))
                        {
                            settings.TestSettingsFile = fileName;
                        }

                        break;
                    }

                    case "PARALLELIZE":
                    {
                        SetParallelSettings(reader.ReadSubtree(), settings);
                        reader.SkipToNextElement();

                        break;
                    }

                    case "TESTTIMEOUT":
                    {
                        if (int.TryParse(reader.ReadInnerXml(), out int testTimeout) && testTimeout > 0)
                        {
                            settings.TestTimeout = testTimeout;
                        }

                        break;
                    }

                    case "TREATCLASSANDASSEMBLYCLEANUPWARNINGSASERRORS":
                    {
                        if (bool.TryParse(reader.ReadInnerXml(), out result))
                        {
                            settings.TreatClassAndAssemblyCleanupWarningsAsErrors = result;
                        }

                        break;
                    }

                    default:
                    {
                        PlatformServiceProvider.Instance.SettingsProvider.Load(reader.ReadSubtree());
                        reader.SkipToNextElement();

                        break;
                    }
                    }
                }
            }

            return(settings);
        }
Exemple #20
0
        public static List <Provider> ParseManifest(XmlReader reader, string fileName = null)
        {
            var ret = new List <Provider>();

            if (reader.ReadToDescendant("events"))
            {
                using (var events = reader.ReadSubtree())
                {
                    if (events.ReadToDescendant("provider"))
                    {
                        do
                        {
                            ret.Add(new Provider(reader, fileName));
                        } while (events.ReadToNextSibling("provider"));
                    }
                }
            }

            // Resolve all the localization strings that may have been used.
            var stringMap = new Dictionary <string, string>();

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "string")
                {
                    var id    = reader.GetAttribute("id");
                    var value = reader.GetAttribute("value");
                    stringMap[id] = value;
                }
            }
            if (0 < stringMap.Count)
            {
                foreach (var provider in ret)
                {
                    if (provider.m_keywordNames != null)
                    {
                        for (int i = 0; i < provider.m_keywordNames.Length; i++)
                        {
                            Provider.Replace(ref provider.m_keywordNames[i], stringMap);
                        }
                    }

                    if (provider.m_taskNames != null)
                    {
                        foreach (var taskId in new List <int>(provider.m_taskNames.Keys))
                        {
                            var taskName = provider.m_taskNames[taskId];
                            if (Provider.Replace(ref taskName, stringMap))
                            {
                                provider.m_taskNames[taskId] = taskName;
                            }
                        }
                    }

                    if (provider.m_opcodeNames != null)
                    {
                        foreach (var opcodeId in new List <int>(provider.m_opcodeNames.Keys))
                        {
                            var opcodeName = provider.m_opcodeNames[opcodeId];
                            if (Provider.Replace(ref opcodeName, stringMap))
                            {
                                provider.m_opcodeNames[opcodeId] = opcodeName;
                            }
                        }
                    }

                    foreach (Event ev in provider.Events)
                    {
                        ev.UpdateStrings(stringMap);
                    }
                }
            }

            return(ret);
        }
Exemple #21
0
        private void AddImages(List <RemoteImageInfo> list, XmlReader reader, CancellationToken cancellationToken)
        {
            reader.MoveToContent();

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case "hdtvlogos":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Logo, 800, 310);
                        }
                        break;
                    }

                    case "hdcleararts":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Art, 1000, 562);
                        }
                        break;
                    }

                    case "clearlogos":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Logo, 400, 155);
                        }
                        break;
                    }

                    case "cleararts":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Art, 500, 281);
                        }
                        break;
                    }

                    case "showbackgrounds":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Backdrop, 1920, 1080, true);
                        }
                        break;
                    }

                    case "seasonthumbs":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Thumb, 500, 281);
                        }
                        break;
                    }

                    case "tvthumbs":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Thumb, 500, 281);
                        }
                        break;
                    }

                    case "tvbanners":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Banner, 1000, 185);
                        }
                        break;
                    }

                    case "tvposters":
                    {
                        using (var subReader = reader.ReadSubtree())
                        {
                            PopulateImageCategory(list, subReader, cancellationToken, ImageType.Primary, 1000, 1426);
                        }
                        break;
                    }

                    default:
                    {
                        using (reader.ReadSubtree())
                        {
                        }
                        break;
                    }
                    }
                }
            }
        }
        /// <summary>
        /// Reads a list of NeatGenome(s) from XML that has a containing 'Root' element. The root
        /// element also contains the activation function library that the genomes are associated with.
        /// </summary>
        /// <param name="xr">The XmlReader to read from.</param>
        /// <param name="nodeFnIds">Indicates if node activation function IDs should be read. If false then
        /// all node activation function IDs default to 0.</param>
        /// <param name="genomeFactory">A NeatGenomeFactory object to construct genomes against.</param>
        public static List <NeatGenome> ReadCompleteGenomeList(XmlReader xr, bool nodeFnIds, NeatGenomeFactory genomeFactory)
        {
            // Find <Root>.
            XmlIoUtils.MoveToElement(xr, false, __ElemRoot);

            // Read IActivationFunctionLibrary. This library is not used, it is compared against the one already present in the
            // genome factory to confirm that the loaded genomes are compatible with the genome factory.
            XmlIoUtils.MoveToElement(xr, true, __ElemActivationFunctions);
            IActivationFunctionLibrary activationFnLib = NetworkXmlIO.ReadActivationFunctionLibrary(xr);

            XmlIoUtils.MoveToElement(xr, false, __ElemNetworks);

            // Read genomes.
            List <NeatGenome> genomeList = new List <NeatGenome>();

            using (XmlReader xrSubtree = xr.ReadSubtree())
            {
                // Re-scan for the root <Networks> element.
                XmlIoUtils.MoveToElement(xrSubtree, false);

                // Move to first Network elem.
                XmlIoUtils.MoveToElement(xrSubtree, true, __ElemNetwork);

                // Read Network elements.
                do
                {
                    NeatGenome genome = ReadGenome(xrSubtree, nodeFnIds);
                    genomeList.Add(genome);
                }while(xrSubtree.ReadToNextSibling(__ElemNetwork));
            }

            // Check for empty list.
            if (genomeList.Count == 0)
            {
                return(genomeList);
            }

            // Get the number of inputs and outputs expected by the genome factory.
            int inputCount  = genomeFactory.InputNeuronCount;
            int outputCount = genomeFactory.OutputNeuronCount;

            // Check all genomes have the same number of inputs & outputs.
            // Also track the highest genomeID and innovation ID values; we need these to construct a new genome factory.
            uint maxGenomeId     = 0;
            uint maxInnovationId = 0;

            foreach (NeatGenome genome in genomeList)
            {
                // Check number of inputs/outputs.
                if (genome.InputNeuronCount != inputCount || genome.OutputNeuronCount != outputCount)
                {
                    throw new SharpNeatException(string.Format("Genome with wrong number of inputs and/or outputs, expected [{0}][{1}] got [{2}][{3}]",
                                                               inputCount, outputCount, genome.InputNeuronCount, genome.OutputNeuronCount));
                }

                // Track max IDs.
                maxGenomeId = Math.Max(maxGenomeId, genome.Id);

                // Node and connection innovation IDs are in the same ID space.
                foreach (NeuronGene nGene in genome.NeuronGeneList)
                {
                    maxInnovationId = Math.Max(maxInnovationId, nGene.InnovationId);
                }

                // Register connection IDs.
                foreach (ConnectionGene cGene in genome.ConnectionGeneList)
                {
                    maxInnovationId = Math.Max(maxInnovationId, cGene.InnovationId);
                }
            }

            // Check that activation functions in XML match that in the genome factory.
            IList <ActivationFunctionInfo> loadedActivationFnList  = activationFnLib.GetFunctionList();
            IList <ActivationFunctionInfo> factoryActivationFnList = genomeFactory.ActivationFnLibrary.GetFunctionList();

            if (loadedActivationFnList.Count != factoryActivationFnList.Count)
            {
                throw new SharpNeatException("The activation function library loaded from XML does not match the genome factory's activation function library.");
            }

            for (int i = 0; i < factoryActivationFnList.Count; i++)
            {
                if ((loadedActivationFnList[i].Id != factoryActivationFnList[i].Id) ||
                    (loadedActivationFnList[i].ActivationFunction.FunctionId != factoryActivationFnList[i].ActivationFunction.FunctionId))
                {
                    throw new SharpNeatException("The activation function library loaded from XML does not match the genome factory's activation function library.");
                }
            }

            // Initialise the genome factory's genome and innovation ID generators.
            genomeFactory.GenomeIdGenerator.Reset(Math.Max(genomeFactory.GenomeIdGenerator.Peek, maxGenomeId + 1));
            genomeFactory.InnovationIdGenerator.Reset(Math.Max(genomeFactory.InnovationIdGenerator.Peek, maxInnovationId + 1));

            // Retrospecitively assign the genome factory to the genomes. This is how we overcome the genome/genomeFactory
            // chicken and egg problem.
            foreach (NeatGenome genome in genomeList)
            {
                genome.GenomeFactory = genomeFactory;
            }

            return(genomeList);
        }
Exemple #23
0
        private void ReadDsmXml(Stream stream)
        {
            Dictionary <string, TreeNode <Element> > nodeMap = new Dictionary <string, TreeNode <Element> >();

            using (XmlReader xReader = XmlReader.Create(stream))
            {
                while (xReader.Read())
                {
                    switch (xReader.NodeType)
                    {
                    case XmlNodeType.Element:
                        if (xReader.Name == "metadatagroup")
                        {
                            string groupName = xReader.GetAttribute("name");
                            List <KeyValuePair <string, string> > groupMetaData = new List <KeyValuePair <string, string> >();
                            _metaData.Add(new KeyValuePair <string, List <KeyValuePair <string, string> > >(groupName, groupMetaData));

                            XmlReader xMetaDataReader = xReader.ReadSubtree();
                            while (xMetaDataReader.Read())
                            {
                                if (xMetaDataReader.Name == "metadata")
                                {
                                    string name  = xMetaDataReader.GetAttribute("name");
                                    string value = xMetaDataReader.GetAttribute("value");
                                    if ((name != null) && (value != null))
                                    {
                                        groupMetaData.Add(new KeyValuePair <string, string>(name, value));
                                    }
                                }
                            }
                        }

                        if (xReader.Name == "element")
                        {
                            string id            = xReader.GetAttribute("idref");
                            string nodeName      = xReader.GetAttribute("name");
                            string parentId      = xReader.GetAttribute("parent");
                            string type          = xReader.GetAttribute("type");
                            string nodeNamespace = xReader.GetAttribute("namespace");

                            Element currentModule = new Element(nodeName, nodeNamespace, type, _elementTypes);

                            TreeNode <Element> parentTreeNode = null;
                            if (nodeMap.ContainsKey(parentId))
                            {
                                parentTreeNode = nodeMap[parentId];
                            }

                            TreeNode <Element> newTreeNode = AddElement(currentModule, currentModule.FullName, parentTreeNode, 0);
                            newTreeNode.NodeValue.Id = int.Parse(id);
                            nodeMap.Add(id, newTreeNode);
                        }

                        if (xReader.Name == "relation")
                        {
                            string consumerId = xReader.GetAttribute("from");
                            string providerId = xReader.GetAttribute("to");
                            int    weight     = int.Parse(xReader.GetAttribute("weight"));
                            string type       = xReader.GetAttribute("type");
                            bool   cyclic     = xReader.GetAttribute("cyclic") == "True";
                            bool   derived    = xReader.GetAttribute("derived") == "True";

                            if ((consumerId != null) && nodeMap.ContainsKey(consumerId) &&
                                (providerId != null) && nodeMap.ContainsKey(providerId))
                            {
                                Element consumer = nodeMap[consumerId].NodeValue;
                                Element provider = nodeMap[providerId].NodeValue;
                                AddRelation(consumer, provider, type, weight, cyclic, derived);
                            }
                        }
                        break;

                    case XmlNodeType.Text:
                        break;

                    case XmlNodeType.EndElement:
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// Reads a NeatGenome from XML.
        /// </summary>
        /// <param name="xr">The XmlReader to read from.</param>
        /// <param name="nodeFnIds">Indicates if node activation function IDs should be read. They are required
        /// for HyperNEAT genomes but not for NEAT</param>
        public static NeatGenome ReadGenome(XmlReader xr, bool nodeFnIds)
        {
            // Find <Network>.
            XmlIoUtils.MoveToElement(xr, false, __ElemNetwork);
            int initialDepth = xr.Depth;

            // Read genome ID attribute if present. Otherwise default to zero; it's the caller's responsibility to
            // check IDs are unique and in-line with the genome factory's ID generators.
            string genomeIdStr = xr.GetAttribute(__AttrId);
            uint   genomeId;

            uint.TryParse(genomeIdStr, out genomeId);

            // Read birthGeneration attribute if present. Otherwise default to zero.
            string birthGenStr = xr.GetAttribute(__AttrBirthGeneration);
            uint   birthGen;

            uint.TryParse(birthGenStr, out birthGen);

            // Find <Nodes>.
            XmlIoUtils.MoveToElement(xr, true, __ElemNodes);

            // Create a reader over the <Nodes> sub-tree.
            int            inputNodeCount  = 0;
            int            outputNodeCount = 0;
            NeuronGeneList nGeneList       = new NeuronGeneList();

            using (XmlReader xrSubtree = xr.ReadSubtree())
            {
                // Re-scan for the root <Nodes> element.
                XmlIoUtils.MoveToElement(xrSubtree, false);

                // Move to first node elem.
                XmlIoUtils.MoveToElement(xrSubtree, true, __ElemNode);

                // Read node elements.
                do
                {
                    NodeType neuronType = NetworkXmlIO.ReadAttributeAsNodeType(xrSubtree, __AttrType);
                    uint     id         = XmlIoUtils.ReadAttributeAsUInt(xrSubtree, __AttrId);
                    int      functionId = 0;
                    double[] auxState   = null;
                    if (nodeFnIds)
                    {   // Read activation fn ID.
                        functionId = XmlIoUtils.ReadAttributeAsInt(xrSubtree, __AttrActivationFunctionId);

                        // Read aux state as comma seperated list of real values.
                        auxState = XmlIoUtils.ReadAttributeAsDoubleArray(xrSubtree, __AttrAuxState);
                    }

                    NeuronGene nGene = new NeuronGene(id, neuronType, functionId, auxState);
                    nGeneList.Add(nGene);

                    // Track the number of input and output nodes.
                    switch (neuronType)
                    {
                    case NodeType.Input:
                        inputNodeCount++;
                        break;

                    case NodeType.Output:
                        outputNodeCount++;
                        break;
                    }
                }while(xrSubtree.ReadToNextSibling(__ElemNode));
            }

            // Find <Connections>.
            XmlIoUtils.MoveToElement(xr, false, __ElemConnections);

            // Create a reader over the <Connections> sub-tree.
            ConnectionGeneList cGeneList = new ConnectionGeneList();

            using (XmlReader xrSubtree = xr.ReadSubtree())
            {
                // Re-scan for the root <Connections> element.
                XmlIoUtils.MoveToElement(xrSubtree, false);

                // Move to first connection elem.
                string localName = XmlIoUtils.MoveToElement(xrSubtree, true);
                if (localName == __ElemConnection)
                {   // We have at least one connection.
                    // Read connection elements.
                    do
                    {
                        uint           id     = XmlIoUtils.ReadAttributeAsUInt(xrSubtree, __AttrId);
                        uint           srcId  = XmlIoUtils.ReadAttributeAsUInt(xrSubtree, __AttrSourceId);
                        uint           tgtId  = XmlIoUtils.ReadAttributeAsUInt(xrSubtree, __AttrTargetId);
                        double         weight = XmlIoUtils.ReadAttributeAsDouble(xrSubtree, __AttrWeight);
                        ConnectionGene cGene  = new ConnectionGene(id, srcId, tgtId, weight);
                        cGeneList.Add(cGene);
                    }while(xrSubtree.ReadToNextSibling(__ElemConnection));
                }
            }

            // Move the reader beyond the closing tags </Connections> and </Network>.
            do
            {
                if (xr.Depth <= initialDepth)
                {
                    break;
                }
            }while(xr.Read());

            // Construct and return loaded NeatGenome.
            return(new NeatGenome(null, genomeId, birthGen, nGeneList, cGeneList, inputNodeCount, outputNodeCount, true));
        }
Exemple #25
0
        internal override void ProcessXmlCore(XmlReader reader)
        {
            switch (reader.Name)
            {
            case "text-representation":
                language = reader["language"];
                script   = reader["script"];
                break;

            case "asin":
                asin = reader.ReadString();
                break;

            case "disc-list":
                if (reader.ReadToDescendant("disc"))
                {
                    List <Disc> discs = new List <Disc> ();
                    do
                    {
                        discs.Add(new Disc(reader.ReadSubtree()));
                    }while (reader.ReadToNextSibling("disc"));
                    this.discs = discs.AsReadOnly();
                }
                break;

            case "release-event-list":
                if (!AllDataLoaded)
                {
                    reader.Skip();  // FIXME this is a workaround for Mono bug 334752
                    return;
                }
                if (reader.ReadToDescendant("event"))
                {
                    List <Event> events = new List <Event> ();
                    do
                    {
                        events.Add(new Event(reader.ReadSubtree()));
                    }while (reader.ReadToNextSibling("event"));
                    this.events = events.AsReadOnly();
                }
                break;

            case "track-list":
                string offset = reader["offset"];
                if (offset != null)
                {
                    track_number = int.Parse(offset) + 1;
                }
                if (reader.ReadToDescendant("track"))
                {
                    List <Track> tracks = new List <Track> ();
                    do
                    {
                        tracks.Add(new Track(reader.ReadSubtree(), GetArtist(), AllDataLoaded));
                    }while (reader.ReadToNextSibling("track"));
                    this.tracks = tracks.AsReadOnly();
                }
                break;

            default:
                base.ProcessXmlCore(reader);
                break;
            }
        }
        /// <summary>
        /// Fetches metadata from one Xml Element
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="itemResult">The item result.</param>
        protected virtual void FetchDataFromXmlNode(XmlReader reader, MetadataResult <T> itemResult)
        {
            var item = itemResult.Item;

            switch (reader.Name)
            {
            // DateCreated
            case "Added":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    DateTime added;
                    if (DateTime.TryParse(val, out added))
                    {
                        item.DateCreated = added.ToUniversalTime();
                    }
                    else
                    {
                        Logger.Warn("Invalid Added value found: " + val);
                    }
                }
                break;
            }

            case "OriginalTitle":
            {
                var val = reader.ReadElementContentAsString();

                var hasOriginalTitle = item as IHasOriginalTitle;
                if (hasOriginalTitle != null)
                {
                    if (!string.IsNullOrEmpty(hasOriginalTitle.OriginalTitle))
                    {
                        hasOriginalTitle.OriginalTitle = val;
                    }
                }
                break;
            }

            case "LocalTitle":
                item.Name = reader.ReadElementContentAsString();
                break;

            case "Type":
            {
                var type = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(type) && !type.Equals("none", StringComparison.OrdinalIgnoreCase))
                {
                    item.DisplayMediaType = type;
                }

                break;
            }

            case "CriticRating":
            {
                var text = reader.ReadElementContentAsString();

                var hasCriticRating = item as IHasCriticRating;

                if (hasCriticRating != null && !string.IsNullOrEmpty(text))
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasCriticRating.CriticRating = value;
                    }
                }

                break;
            }

            case "Budget":
            {
                var text      = reader.ReadElementContentAsString();
                var hasBudget = item as IHasBudget;
                if (hasBudget != null)
                {
                    double value;
                    if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasBudget.Budget = value;
                    }
                }

                break;
            }

            case "Revenue":
            {
                var text      = reader.ReadElementContentAsString();
                var hasBudget = item as IHasBudget;
                if (hasBudget != null)
                {
                    double value;
                    if (double.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasBudget.Revenue = value;
                    }
                }

                break;
            }

            case "Metascore":
            {
                var text         = reader.ReadElementContentAsString();
                var hasMetascore = item as IHasMetascore;
                if (hasMetascore != null)
                {
                    float value;
                    if (float.TryParse(text, NumberStyles.Any, _usCulture, out value))
                    {
                        hasMetascore.Metascore = value;
                    }
                }

                break;
            }

            case "AwardSummary":
            {
                var text      = reader.ReadElementContentAsString();
                var hasAwards = item as IHasAwards;
                if (hasAwards != null)
                {
                    if (!string.IsNullOrWhiteSpace(text))
                    {
                        hasAwards.AwardSummary = text;
                    }
                }

                break;
            }

            case "SortTitle":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.ForcedSortName = val;
                }
                break;
            }

            case "Overview":
            case "Description":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.Overview = val;
                }

                break;
            }

            case "ShortOverview":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasShortOverview = item as IHasShortOverview;

                    if (hasShortOverview != null)
                    {
                        hasShortOverview.ShortOverview = val;
                    }
                }

                break;
            }

            case "CriticRatingSummary":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var hasCriticRating = item as IHasCriticRating;

                    if (hasCriticRating != null)
                    {
                        hasCriticRating.CriticRatingSummary = val;
                    }
                }

                break;
            }

            case "Language":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataLanguage = val;

                break;
            }

            case "CountryCode":
            {
                var val = reader.ReadElementContentAsString();

                item.PreferredMetadataCountryCode = val;

                break;
            }

            case "PlaceOfBirth":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var person = item as Person;
                    if (person != null)
                    {
                        person.PlaceOfBirth = val;
                    }
                }

                break;
            }

            case "Website":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.HomePageUrl = val;
                }

                break;
            }

            case "LockedFields":
            {
                var fields = new List <MetadataFields>();

                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    var list = val.Split('|').Select(i =>
                        {
                            MetadataFields field;

                            if (Enum.TryParse <MetadataFields>(i, true, out field))
                            {
                                return((MetadataFields?)field);
                            }

                            return(null);
                        }).Where(i => i.HasValue).Select(i => i.Value);

                    fields.AddRange(list);
                }

                item.LockedFields = fields;

                break;
            }

            case "TagLines":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromTaglinesNode(subtree, item);
                }
                break;
            }

            case "Countries":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromCountriesNode(subtree, item);
                }
                break;
            }

            case "ContentRating":
            case "MPAARating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRating = rating;
                }
                break;
            }

            case "MPAADescription":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    item.OfficialRatingDescription = rating;
                }
                break;
            }

            case "CustomRating":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.CustomRating = val;
                }
                break;
            }

            case "RunningTime":
            {
                var text = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(text))
                {
                    int runtime;
                    if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out runtime))
                    {
                        item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                    }
                }
                break;
            }

            case "AspectRatio":
            {
                var val = reader.ReadElementContentAsString();

                var hasAspectRatio = item as IHasAspectRatio;
                if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
                {
                    hasAspectRatio.AspectRatio = val;
                }
                break;
            }

            case "LockData":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                }
                break;
            }

            case "Network":
            {
                foreach (var name in SplitNames(reader.ReadElementContentAsString()))
                {
                    if (string.IsNullOrWhiteSpace(name))
                    {
                        continue;
                    }
                    item.AddStudio(name);
                }
                break;
            }

            case "Director":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new Entities.PersonInfo {
                        Name = v.Trim(), Type = PersonType.Director
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Writer":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new Entities.PersonInfo {
                        Name = v.Trim(), Type = PersonType.Writer
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Actors":
            {
                var actors = reader.ReadInnerXml();

                if (actors.Contains("<"))
                {
                    // This is one of the mis-named "Actors" full nodes created by MB2
                    // Create a reader and pass it to the persons node processor
                    FetchDataFromPersonsNode(new XmlTextReader(new StringReader("<Persons>" + actors + "</Persons>")), itemResult);
                }
                else
                {
                    // Old-style piped string
                    foreach (var p in SplitNames(actors).Select(v => new Entities.PersonInfo {
                            Name = v.Trim(), Type = PersonType.Actor
                        }))
                    {
                        if (string.IsNullOrWhiteSpace(p.Name))
                        {
                            continue;
                        }
                        itemResult.AddPerson(p);
                    }
                }
                break;
            }

            case "GuestStars":
            {
                foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new Entities.PersonInfo {
                        Name = v.Trim(), Type = PersonType.GuestStar
                    }))
                {
                    if (string.IsNullOrWhiteSpace(p.Name))
                    {
                        continue;
                    }
                    itemResult.AddPerson(p);
                }
                break;
            }

            case "Trailer":
            {
                var val = reader.ReadElementContentAsString();

                var hasTrailers = item as IHasTrailers;
                if (hasTrailers != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasTrailers.AddTrailerUrl(val, false);
                    }
                }
                break;
            }

            case "DisplayOrder":
            {
                var val = reader.ReadElementContentAsString();

                var hasDisplayOrder = item as IHasDisplayOrder;
                if (hasDisplayOrder != null)
                {
                    if (!string.IsNullOrWhiteSpace(val))
                    {
                        hasDisplayOrder.DisplayOrder = val;
                    }
                }
                break;
            }

            case "Trailers":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    var hasTrailers = item as IHasTrailers;
                    if (hasTrailers != null)
                    {
                        FetchDataFromTrailersNode(subtree, hasTrailers);
                    }
                }
                break;
            }

            case "ProductionYear":
            {
                var val = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(val))
                {
                    int productionYear;
                    if (int.TryParse(val, out productionYear) && productionYear > 1850)
                    {
                        item.ProductionYear = productionYear;
                    }
                }

                break;
            }

            case "Rating":
            case "IMDBrating":
            {
                var rating = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(rating))
                {
                    float val;
                    // All external meta is saving this as '.' for decimal I believe...but just to be sure
                    if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out val))
                    {
                        item.CommunityRating = val;
                    }
                }
                break;
            }

            case "BirthDate":
            case "PremiereDate":
            case "FirstAired":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    DateTime airDate;

                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out airDate) && airDate.Year > 1850)
                    {
                        item.PremiereDate   = airDate.ToUniversalTime();
                        item.ProductionYear = airDate.Year;
                    }
                }

                break;
            }

            case "DeathDate":
            case "EndDate":
            {
                var firstAired = reader.ReadElementContentAsString();

                if (!string.IsNullOrWhiteSpace(firstAired))
                {
                    DateTime airDate;

                    if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out airDate) && airDate.Year > 1850)
                    {
                        item.EndDate = airDate.ToUniversalTime();
                    }
                }

                break;
            }

            case "VoteCount":
            {
                var val = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(val))
                {
                    int num;

                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out num))
                    {
                        item.VoteCount = num;
                    }
                }
                break;
            }

            case "CollectionNumber":
                var tmdbCollection = reader.ReadElementContentAsString();
                if (!string.IsNullOrWhiteSpace(tmdbCollection))
                {
                    item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
                }
                break;

            case "Genres":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromGenresNode(subtree, item);
                }
                break;
            }

            case "Tags":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromTagsNode(subtree, item);
                }
                break;
            }

            case "PlotKeywords":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromKeywordsNode(subtree, item);
                }
                break;
            }

            case "Persons":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchDataFromPersonsNode(subtree, itemResult);
                }
                break;
            }

            case "Studios":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    FetchFromStudiosNode(subtree, item);
                }
                break;
            }

            case "Shares":
            {
                using (var subtree = reader.ReadSubtree())
                {
                    var hasShares = item as IHasShares;
                    if (hasShares != null)
                    {
                        FetchFromSharesNode(subtree, hasShares);
                    }
                }
                break;
            }

            case "Format3D":
            {
                var video = item as Video;

                if (video != null)
                {
                    var val = reader.ReadElementContentAsString();

                    if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.HalfSideBySide;
                    }
                    else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
                    }
                    else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.FullTopAndBottom;
                    }
                    else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.FullSideBySide;
                    }
                    else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
                    {
                        video.Video3DFormat = Video3DFormat.MVC;
                    }
                }
                break;
            }

            default:
            {
                string readerName = reader.Name;
                string providerIdValue;
                if (_validProviderIds.TryGetValue(readerName, out providerIdValue))
                {
                    var id = reader.ReadElementContentAsString();
                    if (!string.IsNullOrWhiteSpace(id))
                    {
                        item.SetProviderId(providerIdValue, id);
                    }
                }
                else
                {
                    reader.Skip();
                }

                break;
            }
            }
        }
Exemple #27
0
        public static List <XmlNodeItem> GetXMLNodesItems(XmlDocument xmlDoc)
        {
            List <XmlNodeItem> returnDict = new List <XmlNodeItem>();
            XmlReader          rdr1       = XmlReader.Create(new System.IO.StringReader(xmlDoc.InnerXml));
            XmlReader          rdr        = XmlReader.Create(new System.IO.StringReader(xmlDoc.InnerXml));
            XmlReader          subrdr     = null;
            string             Elm        = "";

            ArrayList ls = new ArrayList();
            Dictionary <string, int> lspath   = new Dictionary <string, int>();
            List <string>            DeParams = new List <string>();

            while (rdr.Read())
            {
                if (rdr.NodeType == XmlNodeType.Element)
                {
                    Elm = rdr.Name;
                    if (ls.Count <= rdr.Depth)
                    {
                        ls.Add(Elm);
                    }
                    else
                    {
                        ls[rdr.Depth] = Elm;
                    }
                    foreach (var p in DeParams)
                    {
                        if (p == rdr.Name)
                        {
                            subrdr = rdr.ReadSubtree();
                            subrdr.ReadToFollowing(p);
                            returnDict.Add(new XmlNodeItem("AllDescOf" + p, subrdr.ReadInnerXml(), "/" + string.Join("/", ls.ToArray().Take(rdr.Depth))));
                            subrdr = null;
                        }
                    }
                }

                if (rdr.NodeType == XmlNodeType.Text)
                {
                    // soup req contains sub xml, so parse them
                    if (rdr.Value.StartsWith("<?xml"))
                    {
                        XmlDocument xmlnDoc = new XmlDocument();
                        xmlnDoc.LoadXml(rdr.Value);
                        GetXMLNodesItems(xmlnDoc);
                    }
                    else
                    {
                        if (!lspath.Keys.Contains("/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm))
                        {
                            returnDict.Add(new XmlNodeItem(Elm, rdr.Value, "/" + string.Join("/", ls.ToArray().Take(rdr.Depth))));
                            lspath.Add("/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm, 0);
                        }
                        else if (lspath.Keys.Contains("/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm))
                        {
                            returnDict.Add(new XmlNodeItem(Elm + "_" + lspath["/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm], rdr.Value, "/" + string.Join("/", ls.ToArray().Take(rdr.Depth))));
                            lspath["/" + string.Join("/", ls.ToArray().Take(rdr.Depth)) + "/" + Elm]++;
                        }
                    }
                }
            }
            return(returnDict);
        }
Exemple #28
0
    public void ReadXmlPrototype(XmlReader readerParent)
    {
        ObjectType = readerParent.GetAttribute("objectType");

        XmlReader reader = readerParent.ReadSubtree();

        while (reader.Read())
        {
            switch (reader.Name)
            {
            case "Name":
                reader.Read();
                Name = reader.ReadContentAsString();
                break;

            case "TypeTag":
                reader.Read();
                typeTags.Add(reader.ReadContentAsString());
                break;

            case "Description":
                reader.Read();
                description = reader.ReadContentAsString();
                break;

            case "MovementCost":
                reader.Read();
                MovementCost = reader.ReadContentAsFloat();
                break;

            case "PathfindingModifier":
                reader.Read();
                PathfindingModifier = reader.ReadContentAsFloat();
                break;

            case "PathfindingWeight":
                reader.Read();
                PathfindingWeight = reader.ReadContentAsFloat();
                break;

            case "Width":
                reader.Read();
                Width = reader.ReadContentAsInt();
                break;

            case "Height":
                reader.Read();
                Height = reader.ReadContentAsInt();
                break;

            case "LinksToNeighbours":
                reader.Read();
                LinksToNeighbour = reader.ReadContentAsBoolean();
                break;

            case "EnclosesRooms":
                reader.Read();
                RoomEnclosure = reader.ReadContentAsBoolean();
                break;

            case "CanReplaceFurniture":
                replaceableFurniture.Add(reader.GetAttribute("typeTag").ToString());
                break;

            case "DragType":
                reader.Read();
                DragType = reader.ReadContentAsString();
                break;

            case "BuildingJob":
                float jobTime = float.Parse(reader.GetAttribute("jobTime"));

                List <Inventory> invs = new List <Inventory>();

                XmlReader inventoryReader = reader.ReadSubtree();

                while (inventoryReader.Read())
                {
                    if (inventoryReader.Name == "Inventory")
                    {
                        // Found an inventory requirement, so add it to the list!
                        invs.Add(new Inventory(
                                     inventoryReader.GetAttribute("objectType"),
                                     int.Parse(inventoryReader.GetAttribute("amount")),
                                     0));
                    }
                }

                Job j = new Job(
                    null,
                    ObjectType,
                    FurnitureActions.JobComplete_FurnitureBuilding,
                    jobTime,
                    invs.ToArray(),
                    Job.JobPriority.High);
                j.JobDescription = "job_build_" + ObjectType + "_desc";
                PrototypeManager.FurnitureJob.SetPrototype(ObjectType, j);
                break;

            case "CanBeBuiltOn":
                TileType tileType = TileType.GetTileType(reader.GetAttribute("tileType"));
                tileTypeBuildPermissions.Add(tileType);
                break;

            case "Action":
                XmlReader subtree = reader.ReadSubtree();
                EventActions.ReadXml(subtree);
                subtree.Close();
                break;

            case "ContextMenuAction":
                contextMenuLuaActions.Add(new ContextMenuLuaAction
                {
                    LuaFunction = reader.GetAttribute("FunctionName"),
                    Text        = reader.GetAttribute("Text"),
                    RequiereCharacterSelected = bool.Parse(reader.GetAttribute("RequiereCharacterSelected"))
                });
                break;

            case "IsEnterable":
                isEnterableAction = reader.GetAttribute("FunctionName");
                break;

            case "GetSpriteName":
                getSpriteNameAction = reader.GetAttribute("FunctionName");
                break;

            case "JobSpotOffset":
                JobSpotOffset = new Vector2(
                    int.Parse(reader.GetAttribute("X")),
                    int.Parse(reader.GetAttribute("Y")));
                break;

            case "JobSpawnSpotOffset":
                jobSpawnSpotOffset = new Vector2(
                    int.Parse(reader.GetAttribute("X")),
                    int.Parse(reader.GetAttribute("Y")));
                break;

            case "PowerConnection":
                PowerConnection = new Connection();
                PowerConnection.ReadPrototype(reader);
                break;

            case "Params":
                ReadXmlParams(reader);  // Read in the Param tag
                break;

            case "LocalizationCode":
                reader.Read();
                LocalizationCode = reader.ReadContentAsString();
                break;

            case "UnlocalizedDescription":
                reader.Read();
                UnlocalizedDescription = reader.ReadContentAsString();
                break;
            }
        }
    }
Exemple #29
0
            private static ReleaseResult ParseRelease(XmlReader reader, string releaseId)
            {
                var result = new ReleaseResult
                {
                    ReleaseId = releaseId
                };

                reader.MoveToContent();
                reader.Read();

                // http://stackoverflow.com/questions/2299632/why-does-xmlreader-skip-every-other-element-if-there-is-no-whitespace-separator

                // Loop through each element
                while (!reader.EOF && reader.ReadState == ReadState.Interactive)
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "title":
                        {
                            result.Title = reader.ReadElementContentAsString();
                            break;
                        }

                        case "date":
                        {
                            var val = reader.ReadElementContentAsString();
                            if (DateTime.TryParse(val, out var date))
                            {
                                result.Year = date.Year;
                            }

                            break;
                        }

                        case "annotation":
                        {
                            result.Overview = reader.ReadElementContentAsString();
                            break;
                        }

                        case "release-group":
                        {
                            result.ReleaseGroupId = reader.GetAttribute("id");
                            reader.Skip();
                            break;
                        }

                        case "artist-credit":
                        {
                            using (var subReader = reader.ReadSubtree())
                            {
                                var artist = ParseArtistCredit(subReader);

                                if (!string.IsNullOrEmpty(artist.Item1))
                                {
                                    result.Artists.Add(artist);
                                }
                            }

                            break;
                        }

                        default:
                        {
                            reader.Skip();
                            break;
                        }
                        }
                    }
                    else
                    {
                        reader.Read();
                    }
                }

                return(result);
            }
        //=====================================================================

        /// <summary>
        /// This is used to add filenames to the API members in the reflection data file
        /// </summary>
        private void AddApiTopicFilenames()
        {
            this.ReportProgress(BuildStep.AddApiTopicFilenames, "Adding topic filenames to API members...");

            if (!this.ExecutePlugIns(ExecutionBehaviors.InsteadOf))
            {
                this.ExecutePlugIns(ExecutionBehaviors.Before);

                string noFilenames = Path.ChangeExtension(reflectionFile, ".nofilenames");

                File.Move(reflectionFile, noFilenames);

                // Clone the file and add the filename elements
                using (XmlReader reader = XmlReader.Create(noFilenames, new XmlReaderSettings {
                    IgnoreWhitespace = true
                }))
                    using (XmlWriter writer = XmlWriter.Create(reflectionFile, new XmlWriterSettings {
                        Indent = true
                    }))
                        using (ApiTopicNamer namer = new ApiTopicNamer(this))
                        {
                            writer.WriteStartDocument();
                            reader.Read();

                            while (!reader.EOF)
                            {
                                switch (reader.NodeType)
                                {
                                case XmlNodeType.XmlDeclaration:
                                case XmlNodeType.EndElement:
                                    reader.Read();
                                    break;

                                case XmlNodeType.Element:
                                    switch (reader.Name)
                                    {
                                    case "apis":
                                    case "reflection":
                                        writer.WriteStartElement(reader.Name);
                                        reader.Read();
                                        break;

                                    case "api":
                                        string id = reader.GetAttribute("id");

                                        var apiNode = (XElement)XNode.ReadFrom(reader);

                                        apiNode.Add(new XElement("file",
                                                                 new XAttribute("name", namer.ToTopicFileName(id))));

                                        apiNode.WriteTo(writer);
                                        break;

                                    default:
                                        writer.WriteNode(reader.ReadSubtree(), true);
                                        break;
                                    }
                                    break;

                                default:
                                    reader.Read();
                                    break;
                                }
                            }

                            writer.WriteEndDocument();
                        }

                this.ExecutePlugIns(ExecutionBehaviors.After);
            }
        }
Exemple #31
0
 private void Foo(XmlReader reader)
 {
     reader.Read();
     Bar(reader.ReadSubtree());
 }
Exemple #32
0
    private dynamic _ParseValue(XmlReader reader)
    {
        string strToken;

        if (_GetToken(reader, out strToken))
        {
            switch (strToken.ToLower())
            {
                case "true":
                    return true;

                case "false":
                    return false;

                case "string":
                    return reader.ReadString();

                case "date":
                    return DateTime.Parse(reader.ReadString());

                case "integer":
                    return Int64.Parse(reader.ReadString());

                case "dict":
                {
                    XmlReader sub = reader.ReadSubtree();
                    sub.MoveToContent();

                    PropertyList dict = new PropertyList();
                    dict._ParseDictionary(sub);

                    return dict;
                }

                case "array":
                {
                    XmlReader sub = reader.ReadSubtree();
                    sub.MoveToContent();

                    List<PropertyList> list = new List<PropertyList>();
                    while (_NextToken(sub))
                    {
                        string strSubToken;
                        if (_GetToken(reader, out strSubToken) && strSubToken.ToLower() == "dict")
                        {
                            XmlReader subDict = reader.ReadSubtree();
                            subDict.MoveToContent();

                            PropertyList dict = new PropertyList();
                            dict._ParseDictionary(subDict);
                            list.Add(dict);
                        }
                        else
                        {
                            throw new FormatException("Invalid array -- we only support dictionaries");
                        }
                    }

                    return list;
                }

                case "data":
        // TODO: we silently eat "data" elements, eventaully translate these into a object
                    break;

                default:
                {
                    throw new FormatException("Invalid type: " + reader.LocalName.ToLower());
                }
            }
        }

        return null;
    }