Ejemplo n.º 1
0
        /// <summary>
        /// Parses an element string value into a <see cref="CipElement"/>.
        /// </summary>
        /// <param name="elementStr">The element string.</param>
        /// <returns>The new instance of <see cref="CipElement"/>.</returns>
        private static CipElement ParseElement(string elementStr)
        {
            elementStr.ThrowIfNullOrWhiteSpace(nameof(elementStr));

            var attrs          = elementStr.SplitByToken();
            var attributesList = attrs as IList <string> ?? attrs.ToList();
            var hasIdData      = int.TryParse(attributesList.FirstOrDefault(), out int intValue);

            IList <IParsedAttribute> attributes = attributesList.Skip(hasIdData ? 1 : 0).Select(ParseAttribute).ToList();

            var element = new CipElement(hasIdData ? intValue : -1, attributes);

            return(element);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Attempts to parse a string into a <see cref="CipElement"/>.
        /// </summary>
        /// <param name="inputStr">The input string.</param>
        /// <returns>A collection of <see cref="CipElement"/>s parsed.</returns>
        public static IEnumerable <CipElement> Parse(string inputStr)
        {
            if (string.IsNullOrWhiteSpace(inputStr))
            {
                return(null);
            }

            var enclosingChars = new List <(char, char)> {
                (OpenCurly, CloseCurly), (OpenParenthesis, CloseParenthesis)
            };

            inputStr = inputStr.Trim(Space); // remove extra leading and trailing spaces.
            inputStr = inputStr.TrimEnclosures(enclosingChars);

            var enclosures     = inputStr.GetEnclosedStrings(enclosingChars);
            var pendingContent = new Stack <IParsedAttribute>();

            var root = new CipElement(-1, new List <IParsedAttribute>()
            {
                new CipAttribute()
            });

            // root is guaranteed to have at least one attribute.
            pendingContent.Push(root.Attributes.First());

            foreach (var enclosure in enclosures)
            {
                // comma separate but watch for strings in quotes ("").
                var elements = enclosure.SplitByToken(Comma).Select(ParseElement).ToList();

                var attribute = pendingContent.Pop();

                foreach (var element in elements)
                {
                    foreach (var attr in element.Attributes.Where(a => a.Name.Equals(ContentAttributeName)))
                    {
                        pendingContent.Push(attr);
                    }
                }

                attribute.Value = elements;
            }

            return(root.Attributes.First().Value as IEnumerable <CipElement>);
        }