protected virtual bool EvalInExpression(object item, NPathInExpression inExpression)
        {
            object testValue = EvalValue(item, inExpression.TestExpression);

            foreach (object expression in inExpression.Values)
            {
                object value = EvalValue(item, expression);
                int    res   = Comparer.Default.Compare(testValue, value);
                if (res == 0)
                {
                    return(true);
                }
            }
            return(false);
        }
Esempio n. 2
0
        protected virtual void EmitIn(NPathInExpression inExpression)
        {
            EmitExpression(inExpression.TestExpression);
            Write(" in ( ");             // do not localize

            foreach (IValue expression in inExpression.Values)
            {
                EmitExpression(expression);
                if (expression != inExpression.Values[inExpression.Values.Count - 1])
                {
                    Write(",");
                }
            }
            Write(" ) ");
        }
Esempio n. 3
0
        private IValue ParseInExpression(IValue leftOperand)
        {
            NPathInExpression inExpression = new NPathInExpression();

            inExpression.TestExpression = leftOperand;

            tokenizer.GetCurrentToken("in", "in");
            tokenizer.MoveNext();

            tokenizer.GetCurrentToken("(", "(");
            do
            {
                tokenizer.MoveNext();
                IValue expression = ParseExpression();
                inExpression.Values.Add(expression);
            } while (tokenizer.GetCurrentToken().IsType("comma"));

            tokenizer.GetCurrentToken(")", ")");
            tokenizer.MoveNext();

            return(inExpression);
        }
Esempio n. 4
0
        protected virtual void EmitExpression(IValue expression)
        {
            if (expression is NPathNotExpression)
            {
                NPathNotExpression value = (NPathNotExpression)expression;
                EmitNot(value);
            }
            if (expression is NPathFunction)
            {
                NPathFunction value = (NPathFunction)expression;
                EmitFunction(value);
            }
            if (expression is NPathParameter)
            {
                NPathParameter value = (NPathParameter)expression;
                EmitParameter(value);
            }
            if (expression is NPathNullValue)
            {
                NPathNullValue value = (NPathNullValue)expression;
                EmitNullValue(value);
            }
            if (expression is NPathBetweenExpression)
            {
                NPathBetweenExpression value = (NPathBetweenExpression)expression;
                EmitBetween(value);
            }
            if (expression is NPathBooleanValue)
            {
                NPathBooleanValue value = (NPathBooleanValue)expression;
                EmitBooleanValue(value);
            }
            if (expression is NPathDecimalValue)
            {
                NPathDecimalValue value = (NPathDecimalValue)expression;
                EmitDecimalValue(value);
            }
            if (expression is NPathDateTimeValue)
            {
                NPathDateTimeValue value = (NPathDateTimeValue)expression;
                EmitDateTimeValue(value);
            }
            if (expression is NPathGuidValue)
            {
                NPathGuidValue value = (NPathGuidValue)expression;
                EmitGuidValue(value);
            }
            if (expression is NPathStringValue)
            {
                NPathStringValue value = (NPathStringValue)expression;
                EmitStringValue(value);
            }
            if (expression is NPathIdentifier)
            {
                NPathIdentifier propertyPath = (NPathIdentifier)expression;
                EmitPropertyPath(propertyPath);
            }
            if (expression is NPathPropertyFilter)
            {
                NPathPropertyFilter propertyFilter = (NPathPropertyFilter)expression;
                EmitPropertyFilter(propertyFilter);
            }
            if (expression is NPathParenthesisGroup)
            {
                NPathParenthesisGroup parenthesisGroup = (NPathParenthesisGroup)expression;
                EmitParenthesisGroup(parenthesisGroup);
            }
            if (expression is NPathMathExpression)
            {
                NPathMathExpression mathExpression = (NPathMathExpression)expression;
                EmitMathExpression(mathExpression);
            }
            if (expression is NPathCompareExpression)
            {
                NPathCompareExpression compareExpression = (NPathCompareExpression)expression;
                EmitCompareExpression(compareExpression);
            }

            if (expression is NPathBooleanExpression)
            {
                NPathBooleanExpression boolExpression = (NPathBooleanExpression)expression;
                EmitBooleanExpression(boolExpression);
            }
            if (expression is NPathInExpression)
            {
                NPathInExpression value = (NPathInExpression)expression;
                EmitIn(value);
            }
            if (expression is NPathSearchFunction)
            {
                NPathSearchFunction value = (NPathSearchFunction)expression;
                EmitSearchFunction(value);
            }
        }