internal static bool TryParse(ReadOnlySpan <char> expr, out int advance, out JsonPathNode node)
        {
            advance = default;
            node    = default;

            if (expr.Length <= 3)
            {
                return(false);
            }

            if (expr[0] != '[')
            {
                return(false);
            }

            int i = expr.IndexOf(']');

            if (i == -1)
            {
                return(false);
            }

            if (!int.TryParse(expr.Slice(1, i - 1).ToString(), out int index))
            {
                return(false);
            }

            advance = i + 1;
            node    = new JsonPathIndexSelectorNode()
            {
                Index = index
            };

            return(true);
        }
Exemple #2
0
        private IEnumerable <JsonPathNode> ParseNodes(ReadOnlyMemory <char> exprMem)
        {
            ReadOnlySpan <char> expr;

            while (!exprMem.IsEmpty)
            {
                expr = exprMem.Span;
                JsonPathNode node = Parse(ref expr);
                exprMem = expr.ToArray();
                yield return(node);
            }
        }
        internal static bool TryParse(ReadOnlySpan <char> expr, out int advance, out JsonPathNode node)
        {
            advance = default;
            node    = default;

            if (expr.Length != 1 || expr[0] != '*')
            {
                return(false);
            }

            advance = expr.Length;
            node    = new JsonPathFilterWildcardNode();
            return(true);
        }
        internal static bool TryParse(ReadOnlySpan <char> expr, out int advance, out JsonPathNode node)
        {
            advance = default;
            node    = default;

            if (expr.Length <= 3)
            {
                return(false);
            }

            if (expr[1] == '\'')
            {
                return(false);
            }

            if (expr[0] != '[')
            {
                return(false);
            }

            int nesting = 1;
            int i       = 1;

            for (; i < expr.Length && nesting != 0; ++i)
            {
                if (expr[i] == '[')
                {
                    ++nesting;
                }
                else if (expr[i] == ']')
                {
                    --nesting;
                }
            }

            if (nesting != 0)
            {
                return(false);
            }

            advance = expr.Length;
            node    = new JsonPathItemsSelectorNode(expr.Slice(i))
            {
                FilterRoot = new JsonPathFilterRootNode(expr.Slice(1, i - 2))
            };

            return(true);
        }
        internal static bool TryParse(ReadOnlySpan <char> expr, out int advance, out JsonPathNode node)
        {
            advance = default;
            node    = default;

            if (expr.Length < 4)
            {
                return(false);
            }

            if (!expr.StartsWith("?(".AsSpan()))
            {
                return(false);
            }

            if (expr[expr.Length - 1] != ')')
            {
                return(false);
            }

            throw new NotImplementedException();

            return(true);
        }
        internal static bool TryParse(ReadOnlySpan <char> expr, out int advance, out JsonPathNode node)
        {
            advance = default;
            node    = default;

            if (expr.Length <= 2)
            {
                return(false);
            }

            if (expr[1] == '*')
            {
                return(false);
            }

            if (expr[1] == '.')
            {
                return(false);
            }

            if (expr[0] == '.')
            {
                Match identifier = CSharpIdentifierRegex.Match(expr.Slice(1).ToString());

                if (!identifier.Success)
                {
                    return(false);
                }

                advance = identifier.Length + 1;
                node    = new JsonPathPropertySelectorNode()
                {
                    PropertyName = identifier.Value
                };

                return(true);
            }

            if (expr[0] == '[' && expr[1] == '\'')
            {
                Match identifier = CSharpIdentifierRegex.Match(expr.Slice(2).ToString());

                if (!identifier.Success)
                {
                    return(false);
                }

                if (!expr.Slice(identifier.Length + 2).StartsWith("']".AsSpan()))
                {
                    return(false);
                }

                advance = identifier.Length + 4;
                node    = new JsonPathPropertySelectorNode()
                {
                    PropertyName = identifier.Value
                };

                return(true);
            }

            return(false);
        }