public static CompiledExpression Compile(Expression expression, NameResolver nameResolver)
        {
            var actual = expression;

            actual = VariadicCallRewriter.Rewrite(actual);
            actual = TextMatchingTransformer.Rewrite(actual);
            actual = LikeSyntaxTransformer.Rewrite(actual);
            actual = PropertiesObjectAccessorTransformer.Rewrite(actual);
            actual = ConstantArrayEvaluator.Evaluate(actual);
            actual = WildcardComprehensionTransformer.Expand(actual);

            return(LinqExpressionCompiler.Compile(actual, nameResolver));
        }
Ejemplo n.º 2
0
        public static object ElementAt(object items, object index)
        {
            var arr = items as SequenceValue;

            if (arr != null)
            {
                if (!(index is decimal))
                {
                    return(Undefined.Value);
                }

                var dec = (decimal)index;
                if (dec != Math.Floor(dec))
                {
                    return(Undefined.Value);
                }

                var idx = (int)dec;
                if (idx >= arr.Elements.Count())
                {
                    return(Undefined.Value);
                }

                return(Representation.Represent(arr.Elements.ElementAt(idx)));
            }

            var dict = items as StructureValue;

            if (dict != null)
            {
                var s = index as string;
                if (s == null)
                {
                    return(Undefined.Value);
                }

                LogEventPropertyValue value;
                if (!LinqExpressionCompiler.TryGetStructurePropertyValue(dict, s, out value))
                {
                    return(Undefined.Value);
                }

                return(Representation.Represent(value));
            }

            return(Undefined.Value);
        }
Ejemplo n.º 3
0
        public static Func <LogEvent, object> CompileAndExpose(FilterExpression expression)
        {
            var actual = expression;

            actual = PropertiesObjectAccessorTransformer.Rewrite(actual);
            actual = WildcardComprehensionTransformer.Expand(actual);
            actual = LikeOperatorTransformer.Rewrite(actual);
            actual = IsOperatorTransformer.Rewrite(actual);
            actual = FilterExpressionCostReordering.Reorder(actual);
            actual = TextMatchingTransformer.Rewrite(actual);

            var compiled = LinqExpressionCompiler.Compile(actual);

            return(ctx =>
            {
                var result = compiled(ctx);
                return Representation.Expose(result);
            });
        }