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 TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
bool inMemory,
out Expression expression)
{
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
type.ParseLiteral(value) is bool parsedValue)
{
MemberExpression property =
Expression.Property(instance, operation.Property);
Type propertType = operation.Type;
if (operation.TryGetSimpleFilterBaseType(out Type baseType))
{
propertType = baseType;
}
if (parsedValue)
{
expression = FilterExpressionBuilder.Any(
propertType,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
propertType,
property));
}
if (inMemory)
{
expression = FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
return(true);
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?expression)
{
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
context.InputParser.ParseLiteral(value, type) is bool parsedValue)
{
MemberExpression property =
Expression.Property(context.GetInstance(), operation.Property);
Type propertyType = operation.Type;
if (operation.TryGetSimpleFilterBaseType(out Type? baseType))
{
propertyType = baseType;
}
if (parsedValue)
{
expression = FilterExpressionBuilder.Any(
propertyType,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
propertyType,
property));
}
if (context.InMemory)
{
expression =
FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
return(true);
}
expression = null;
return(false);
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
type.ParseLiteral(value) is bool parsedValue)
{
Expression property = instance;
if (!operation.IsSimpleArrayType())
{
property = Expression.Property(instance, operation.Property);
}
if (parsedValue)
{
expression = FilterExpressionBuilder.Any(
operation.Type,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
operation.Type,
property));
}
return(true);
}
expression = null;
return(false);
}
public static bool ArrayAny(
FilterOperation operation,
IInputType type,
IValueNode value,
IQueryableFilterVisitorContext context,
[NotNullWhen(true)] out Expression?result)
{
object parsedValue = type.ParseLiteral(value);
if (parsedValue == null)
{
context.ReportError(
ErrorHelper.CreateNonNullError(operation, type, value, context));
result = null;
return(false);
}
if (operation.Kind == FilterOperationKind.ArrayAny &&
type.IsInstanceOfType(value) &&
parsedValue is bool parsedBool)
{
MemberExpression property =
Expression.Property(context.GetInstance(), operation.Property);
Type propertType = operation.Type;
if (operation.TryGetSimpleFilterBaseType(out Type? baseType))
{
propertType = baseType;
}
Expression expression;
if (parsedBool)
{
expression = FilterExpressionBuilder.Any(
propertType,
property);
}
else
{
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Any(
propertType,
property));
}
if (context.InMemory)
{
expression =
FilterExpressionBuilder.NotNullAndAlso(property, expression);
}
result = expression;
return(true);
}
else
{
throw new InvalidOperationException();
}
}