protected override FilterExpressionCosting Transform(FilterSubpropertyExpression spx)
        {
            var receiver = Transform(spx.Receiver);

            return(new FilterExpressionCosting(
                       new FilterSubpropertyExpression(spx.PropertyName, receiver.Expression),
                       receiver.Costing + 0.1));
        }
示例#2
0
        protected override FilterExpression Transform(FilterSubpropertyExpression spx)
        {
            if (spx == _source)
            {
                return(_dest);
            }

            return(base.Transform(spx));
        }
        protected override Expression <CompiledFilterExpression> Transform(FilterSubpropertyExpression spx)
        {
            var tgv  = typeof(LinqExpressionCompiler).GetTypeInfo().GetMethod(nameof(TryGetStructurePropertyValue), BindingFlags.Static | BindingFlags.Public);
            var norm = typeof(Representation).GetTypeInfo().GetMethod(nameof(Representation.Represent), BindingFlags.Static | BindingFlags.Public);

            var recv = Transform(spx.Receiver);

            var context = Expression.Parameter(typeof(LogEvent));

            var r      = Expression.Variable(typeof(object));
            var str    = Expression.Variable(typeof(StructureValue));
            var result = Expression.Variable(typeof(LogEventPropertyValue));

            var sx3 = Expression.Call(tgv, str, Expression.Constant(spx.PropertyName, typeof(string)), result);

            var sx1 = Expression.Condition(sx3,
                                           Expression.Call(norm, result),
                                           Expression.Constant(Undefined.Value, typeof(object)));

            var sx2 = Expression.Block(typeof(object),
                                       Expression.Assign(str, Expression.TypeAs(r, typeof(StructureValue))),
                                       Expression.Condition(Expression.Equal(str, Expression.Constant(null, typeof(StructureValue))),
                                                            Expression.Constant(Undefined.Value, typeof(object)),
                                                            sx1));

            var assignR  = Expression.Assign(r, Splice(recv, context));
            var getValue = Expression.Condition(Expression.TypeIs(r, typeof(Undefined)),
                                                Expression.Constant(Undefined.Value, typeof(object)),
                                                sx2);

            return(Expression.Lambda <CompiledFilterExpression>(
                       Expression.Block(typeof(object), new[] { r, str, result }, assignR, getValue),
                       context));

            //return context =>
            //{
            //    var r = recv(context);
            //    if (r is Undefined)
            //        return Undefined.Value;

            //    var str = r as StructureValue;
            //    if (str == null)
            //        return Undefined.Value;

            //    LogEventPropertyValue result;
            //    if (!str.Properties.TryGetValue(spx.PropertyName, out result))
            //        return Undefined.Value;

            //    return Represent(result);
            //};
        }
 protected override FilterExpression Transform(FilterSubpropertyExpression spx)
 {
     return(new FilterSubpropertyExpression(spx.PropertyName, Transform(spx.Receiver)));
 }
 protected override FilterCallExpression Transform(FilterSubpropertyExpression spx)
 {
     return(Transform(spx.Receiver));
 }
示例#6
0
 protected abstract TResult Transform(FilterSubpropertyExpression spx);