Пример #1
0
        private string EvaluateToString(TNodeOrToken node, ISyntaxFilterExpression expression)
        {
            switch (expression)
            {
            case SyntaxQuery query: {
                var first = QueryAll(node, query).FirstOrDefault();
                return(EvaluateToString(first));
            }

            case SyntaxFilterLiteralExpression literal:
                return(literal.Value);

            default:
                throw new NotSupportedException($"Expression canno be evaluated to a single value: {expression}.");
            }
        }
Пример #2
0
        private bool MatchesFilter(TNodeOrToken node, ISyntaxFilterExpression filter)
        {
            if (filter == null)
            {
                return(true);
            }
            switch (filter)
            {
            case SyntaxQuery query:
                return(QueryAll(node, query).Any());

            case SyntaxFilterBinaryExpression binary:
                return(MatchesFilterBinary(node, binary));

            default:
                throw new NotSupportedException($"Unknown filter type: {filter.GetType()}.");
            }
        }
        private string EvaluateToString(SyntaxNodeOrToken nodeOrToken, ISyntaxFilterExpression expression)
        {
            switch (expression)
            {
            case SyntaxQuery query: {
                var node = nodeOrToken.AsNode();
                if (node == null)
                {
                    return(null);    // TODO?
                }
                var first = QueryAll((CSharpSyntaxNode)node, query).FirstOrDefault();
                return(EvaluateToString(first));
            }

            case SyntaxFilterLiteralExpression literal:
                return(literal.Value);

            default:
                throw new NotSupportedException($"Expression canno be evaluated to a single value: {expression}.");
            }
        }
        private bool MatchesFilter(SyntaxNodeOrToken nodeOrToken, ISyntaxFilterExpression filter)
        {
            if (filter == null)
            {
                return(true);
            }
            switch (filter)
            {
            case SyntaxQuery query: {
                var node = nodeOrToken.AsNode();
                if (node == null)
                {
                    return(false);    // TODO?
                }
                return(QueryAll((CSharpSyntaxNode)node, query).Any());
            }

            case SyntaxFilterBinaryExpression binary:
                return(MatchesFilterBinary(nodeOrToken, binary));

            default:
                throw new NotSupportedException($"Unknown filter type: {filter.GetType()}.");
            }
        }
 public SyntaxFilterBinaryExpression(ISyntaxFilterExpression left, SyntaxFilterBinaryOperator @operator, ISyntaxFilterExpression right)
 {
     Left     = left;
     Operator = @operator;
     Right    = right;
 }
Пример #6
0
 public SyntaxQuery(SyntaxQueryAxis axis, SyntaxQueryKeyword keyword, ISyntaxFilterExpression filter)
 {
     Axis    = axis;
     Keyword = keyword;
     Filter  = filter;
 }