protected override FilterExpression Transform(FilterCallExpression lx)
{
if (!Operators.WildcardComparators.Contains(lx.OperatorName) || lx.Operands.Length != 2)
{
return(base.Transform(lx));
}
var lhsIs = FilterExpressionWildcardSearch.FindElementAtWildcard(lx.Operands[0]);
var rhsIs = FilterExpressionWildcardSearch.FindElementAtWildcard(lx.Operands[1]);
if (lhsIs != null && rhsIs != null || lhsIs == null && rhsIs == null)
{
return(base.Transform(lx)); // N/A, or invalid
}
var wcpath = lhsIs != null ? lx.Operands[0] : lx.Operands[1];
var comparand = lhsIs != null ? lx.Operands[1] : lx.Operands[0];
var elmat = lhsIs ?? rhsIs;
var parm = new FilterParameterExpression("p" + _nextParameter++);
var nestedComparand = FilterExpressionNodeReplacer.Replace(wcpath, elmat, parm);
var coll = elmat.Operands[0];
var wc = ((FilterWildcardExpression)elmat.Operands[1]).Wildcard;
var comparisonArgs = lhsIs != null ? new[] { nestedComparand, comparand } : new[] { comparand, nestedComparand };
var body = new FilterCallExpression(lx.OperatorName, comparisonArgs);
var lambda = new FilterLambdaExpression(new[] { parm }, body);
var op = Operators.ToRuntimeWildcardOperator(wc);
var call = new FilterCallExpression(op, new[] { coll, lambda });
return(Transform(call));
}
protected override Expression <CompiledFilterExpression> Transform(FilterLambdaExpression lmx)
{
var context = Expression.Parameter(typeof(LogEvent));
var parms = lmx.Parameters.Select(px => Tuple.Create(px, Expression.Parameter(typeof(object), px.ParameterName))).ToList();
var body = Splice(Transform(lmx.Body), context);
var paramSwitcher = new ExpressionConstantMapper(parms.ToDictionary(px => (object)px.Item1, px => (Expression)px.Item2));
var rewritten = paramSwitcher.Visit(body);
Type delegateType;
if (lmx.Parameters.Length == 1)
{
delegateType = typeof(Func <object, object>);
}
else if (lmx.Parameters.Length == 2)
{
delegateType = typeof(Func <object, object, object>);
}
else
{
throw new NotSupportedException("Unsupported lambda signature");
}
var lambda = Expression.Lambda(delegateType, rewritten, parms.Select(px => px.Item2).ToArray());
return(Expression.Lambda <CompiledFilterExpression>(lambda, new[] { context }));
}
protected override FilterExpressionCosting Transform(FilterLambdaExpression lmx)
{
var body = Transform(lmx.Body);
return(new FilterExpressionCosting(
new FilterLambdaExpression(lmx.Parameters, body.Expression),
body.Costing + 0.1));
}
protected override FilterExpression Transform(FilterLambdaExpression lmx)
{
if (lmx == _source)
{
return(_dest);
}
return(base.Transform(lmx));
}
protected override FilterExpression Transform(FilterLambdaExpression lmx)
{
// By default we maintain the parameters available in the body
return(new FilterLambdaExpression(lmx.Parameters, Transform(lmx.Body)));
}
protected override FilterCallExpression Transform(FilterLambdaExpression lmx)
{
return(null);
}
protected abstract TResult Transform(FilterLambdaExpression lmx);
