Beispiel #1
0
        /// <summary>
        /// Executa o parse na expressão com um texto.
        /// </summary>
        /// <returns></returns>
        private IFilterNode ParseStringExpression()
        {
            FilterToken token = this.Expect(FilterTokenType.String);

            return(new StringNode {
                Value = token.Value
            });
        }
Beispiel #2
0
        /// <summary>
        /// Executa o parse na expressão contendo um número.
        /// </summary>
        /// <returns></returns>
        private IFilterNode ParseNumberExpression()
        {
            FilterToken token = this.Expect(FilterTokenType.Number);

            return(new NumberNode {
                Value = Convert.ToDouble(token.Value, System.Globalization.CultureInfo.InvariantCulture)
            });
        }
Beispiel #3
0
        /// <summary>
        /// Executa o parser na expressão com os dado da propriedade.
        /// </summary>
        /// <returns></returns>
        private IFilterNode ParsePropertyExpression()
        {
            FilterToken token = this.Expect(FilterTokenType.Property);

            return(new PropertyNode {
                Name = token.Value
            });
        }
Beispiel #4
0
        /// <summary>
        /// Executa o parse em uma expressão com um DateTime.
        /// </summary>
        /// <returns></returns>
        private IFilterNode ParseDateTimeExpression()
        {
            FilterToken token = this.Expect(FilterTokenType.DateTime);

            return(new DateTimeNode {
                Value = DateTime.ParseExact(token.Value, "yyyy-MM-ddTHH-mm-ss", null)
            });
        }
Beispiel #5
0
        /// <summary>
        /// Executa o parse sobre um nó com o valor boolean.
        /// </summary>
        /// <returns></returns>
        private IFilterNode ParseBoolean()
        {
            FilterToken token = this.Expect(FilterTokenType.Boolean);

            return(new BooleanNode {
                Value = Convert.ToBoolean(token.Value)
            });
        }
Beispiel #6
0
        /// <summary>
        /// Espera pelo tipo de token.
        /// </summary>
        /// <param name="tokenType"></param>
        /// <returns></returns>
        private FilterToken Expect(FilterTokenType tokenType)
        {
            if (!Is(tokenType))
            {
                throw new FilterParserException("Expected " + tokenType);
            }
            FilterToken token = this.Peek();

            _currentTokenIndex++;
            return(token);
        }
Beispiel #7
0
        /// <summary>
        /// Executa o parse na expressão com uma função.
        /// </summary>
        /// <returns></returns>
        private IFilterNode ParseFunctionExpression()
        {
            FilterToken  token = this.Expect(FilterTokenType.Function);
            FunctionNode node  = new FunctionNode {
                FilterOperator = token.ToFilterOperator()
            };

            this.Expect(FilterTokenType.LeftParenthesis);
            node.Arguments.Add(this.Expression());
            while (this.Is(FilterTokenType.Comma))
            {
                this.Expect(FilterTokenType.Comma);
                node.Arguments.Add(this.Expression());
            }
            this.Expect(FilterTokenType.RightParenthesis);
            return(node);
        }
Beispiel #8
0
        /// <summary>
        /// Executa o parser a expressão de comparação.
        /// </summary>
        /// <param name="firstArgument"></param>
        /// <returns></returns>
        private IFilterNode ParseComparisonExpression(IFilterNode firstArgument)
        {
            if (this.Is(FilterTokenType.ComparisonOperator))
            {
                FilterToken token = this.Expect(FilterTokenType.ComparisonOperator);
                IFilterNode node  = this.PrimaryExpression();
                return(new ComparisonNode {
                    First = firstArgument,
                    FilterOperator = token.ToFilterOperator(),
                    Second = node
                });
            }
            FilterToken  token2 = this.Expect(FilterTokenType.Function);
            FunctionNode node3  = new FunctionNode {
                FilterOperator = token2.ToFilterOperator()
            };

            node3.Arguments.Add(firstArgument);
            node3.Arguments.Add(this.PrimaryExpression());
            return(node3);
        }
Beispiel #9
0
        /// <summary>
        /// Verifica se o atual toke é do tipo informado.
        /// </summary>
        /// <param name="tokenType"></param>
        /// <returns></returns>
        private bool Is(FilterTokenType tokenType)
        {
            FilterToken token = Peek();

            return((token != null) && (token.TokenType == tokenType));
        }