public bool Enter(
FilterOperationField field,
ObjectFieldNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors,
Stack <QueryableClosure> closures,
bool inMemory,
out VisitorAction action
)
{
if (
field.Operation.Kind == FilterOperationKind.ArraySome ||
field.Operation.Kind == FilterOperationKind.ArrayNone ||
field.Operation.Kind == FilterOperationKind.ArrayAll
)
{
MemberExpression nestedProperty = Expression.Property(
closures.Peek().Instance.Peek(),
field.Operation.Property
);
closures.Peek().Instance.Push(nestedProperty);
Type closureType = GetTypeFor(field.Operation);
closures.Push(new QueryableClosure(closureType, "_s" + closures.Count, inMemory));
action = VisitorAction.Continue;
return(true);
}
action = VisitorAction.Default;
return(false);
}
public bool Enter(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context,
out ISyntaxVisitorAction action)
{
if (field.Operation.Kind == FilterOperationKind.ArraySome ||
field.Operation.Kind == FilterOperationKind.ArrayNone ||
field.Operation.Kind == FilterOperationKind.ArrayAll)
{
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
context.PushInstance(nestedProperty);
Type closureType = GetTypeFor(field.Operation);
context.AddClosure(closureType);
action = SyntaxVisitor.Continue;
return(true);
}
action = SyntaxVisitor.Skip;
return(false);
}
public void Leave(
FilterOperationField field,
ObjectFieldNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors,
Stack <QueryableClosure> closures,
bool inMemory)
{
if (field.Operation.Kind == FilterOperationKind.Object)
{
// Deque last expression to prefix with nullcheck
Expression condition = closures.Peek().Level.Peek().Dequeue();
Expression property = closures.Peek().Instance.Peek();
// wrap last expression only if in memory
if (inMemory)
{
condition = FilterExpressionBuilder.NotNullAndAlso(
property, condition);
}
closures.Peek().Level.Peek().Enqueue(condition);
closures.Peek().Instance.Pop();
}
}
public void Leave(
FilterOperationField field,
ObjectFieldNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors,
Stack <QueryableClosure> closures,
bool inMemory)
{
if (field.Operation.Kind == FilterOperationKind.ArraySome ||
field.Operation.Kind == FilterOperationKind.ArrayNone ||
field.Operation.Kind == FilterOperationKind.ArrayAll)
{
QueryableClosure nestedClosure = closures.Pop();
LambdaExpression lambda = nestedClosure.CreateLambda();
Type closureType = GetTypeFor(field.Operation);
Expression expression;
switch (field.Operation.Kind)
{
case FilterOperationKind.ArraySome:
expression = FilterExpressionBuilder.Any(
closureType,
closures.Peek().Instance.Peek(),
lambda
);
break;
case FilterOperationKind.ArrayNone:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
closureType,
closures.Peek().Instance.Peek(),
lambda
)
);
break;
case FilterOperationKind.ArrayAll:
expression = FilterExpressionBuilder.All(
closureType,
closures.Peek().Instance.Peek(),
lambda
);
break;
default:
throw new NotSupportedException();
}
if (inMemory)
{
expression = FilterExpressionBuilder.NotNullAndAlso(
closures.Peek().Instance.Peek(), expression);
}
closures.Peek().Level.Peek().Enqueue(expression);
closures.Peek().Instance.Pop();
}
}
public void Leave(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context)
{
if (field.Operation.Kind == FilterOperationKind.ArraySome ||
field.Operation.Kind == FilterOperationKind.ArrayNone ||
field.Operation.Kind == FilterOperationKind.ArrayAll)
{
QueryableClosure nestedClosure = context.PopClosure();
LambdaExpression lambda = nestedClosure.CreateLambda();
Type closureType = GetTypeFor(field.Operation);
Expression expression;
switch (field.Operation.Kind)
{
case FilterOperationKind.ArraySome:
expression = FilterExpressionBuilder.Any(
closureType,
context.GetInstance(),
lambda
);
break;
case FilterOperationKind.ArrayNone:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
closureType,
context.GetInstance(),
lambda
)
);
break;
case FilterOperationKind.ArrayAll:
expression = FilterExpressionBuilder.All(
closureType,
context.GetInstance(),
lambda
);
break;
default:
throw new NotSupportedException();
}
if (context.InMemory)
{
expression = FilterExpressionBuilder.NotNullAndAlso(
context.GetInstance(), expression);
}
context.GetLevel().Enqueue(expression);
context.PopInstance();
}
}
public bool Enter(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context,
out ISyntaxVisitorAction action)
{
if (field.Operation.Kind == FilterOperationKind.Object)
{
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
context.PushInstance(nestedProperty);
action = SyntaxVisitor.Continue;
return(true);
}
action = SyntaxVisitor.SkipAndLeave;
return(false);
}
public static bool Enter(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out ISyntaxVisitorAction?action)
{
if (node.Value.IsNull())
{
if (field.Operation.IsNullable)
{
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
Expression expression =
FilterExpressionBuilder.Equals(nestedProperty, null !);
context.GetLevel().Enqueue(expression);
}
else
{
context.ReportError(
ErrorHelper.CreateNonNullError(field, node, context));
}
action = SyntaxVisitor.Skip;
return(true);
}
if (field.Operation.Kind == FilterOperationKind.Object)
{
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
context.PushInstance(nestedProperty);
action = SyntaxVisitor.Continue;
return(true);
}
action = null;
return(false);
}
public static bool Enter(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out ISyntaxVisitorAction?action)
{
if (field.Operation.Kind == FilterOperationKind.ArraySome ||
field.Operation.Kind == FilterOperationKind.ArrayNone ||
field.Operation.Kind == FilterOperationKind.ArrayAll)
{
if (!field.Operation.IsNullable && node.Value.IsNull())
{
context.ReportError(
ErrorHelper.CreateNonNullError(field, node, context));
action = SyntaxVisitor.Skip;
return(true);
}
MemberExpression nestedProperty = Expression.Property(
context.GetInstance(),
field.Operation.Property);
context.PushInstance(nestedProperty);
Type closureType = GetTypeFor(field.Operation);
if (node.Value.IsNull())
{
context.AddIsNullClosure(closureType);
action = SyntaxVisitor.SkipAndLeave;
}
else
{
context.AddClosure(closureType);
action = SyntaxVisitor.Continue;
}
return(true);
}
action = null;
return(false);
}
public bool Enter(
FilterOperationField field,
ObjectFieldNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors,
Stack <QueryableClosure> closures,
out VisitorAction action)
{
if (field.Operation.Kind == FilterOperationKind.Object)
{
var nestedProperty = Expression.Property(
closures.Peek().Instance.Peek(),
field.Operation.Property);
closures.Peek().Instance.Push(nestedProperty);
action = VisitorAction.Continue;
return(true);
}
action = VisitorAction.Default;
return(false);
}
public static void Leave(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context)
{
if (field.Operation.Kind == FilterOperationKind.Object)
{
// Deque last expression to prefix with nullcheck
Expression condition = context.GetLevel().Dequeue();
Expression property = context.GetInstance();
// wrap last expression only if in memory
if (context.InMemory)
{
condition = FilterExpressionBuilder.NotNullAndAlso(
property, condition);
}
context.GetLevel().Enqueue(condition);
context.PopInstance();
}
}
public static IError CreateNonNullError(
FilterOperationField field,
ObjectFieldNode node,
IQueryableFilterVisitorContext context) =>
CreateNonNullError(field.Operation, field.Type, node.Value, context);
