public override FilterNode <TValue>?Visit(NegateFilter <TValue> nodeIn, None args)
{
var pruned = nodeIn.Filter.Accept(this, None.Value);
if (pruned == null)
{
return(null);
}
if (pruned is CompareFilter <TValue> comparison)
{
if (comparison.Operator == CompareOperator.Equals)
{
return(comparison with {
Operator = CompareOperator.NotEquals
});
}
if (comparison.Operator == CompareOperator.NotEquals)
{
return(comparison with {
Operator = CompareOperator.Equals
});
}
}
if (ReferenceEquals(pruned, nodeIn.Filter))
{
return(nodeIn);
}
return(new NegateFilter <TValue>(pruned));
}
public override FilterNode <TValue>?Visit(NegateFilter <TValue> nodeIn, TArgs args)
{
var inner = nodeIn.Filter.Accept(this, args);
if (inner == null)
{
return(inner);
}
return(new NegateFilter <TValue>(inner));
}
public override FilterDefinition <T> Visit(NegateFilter <ClrValue> nodeIn, None args)
{
return(Filter.Not(nodeIn.Filter.Accept(this, args)));
}
protected override FilterNode <IJsonValue> ReadValue(JsonReader reader, Type objectType, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject)
{
throw new JsonException($"Expected StartObject, but got {reader.TokenType}.");
}
FilterNode <IJsonValue> result = null;
var comparePath = (PropertyPath)null;
var compareOperator = (CompareOperator)99;
var compareValue = (IJsonValue)null;
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string propertyName = reader.Value.ToString();
if (!reader.Read())
{
throw new JsonSerializationException("Unexpected end when reading filter.");
}
if (result != null)
{
throw new JsonSerializationException($"Unexpected property {propertyName}");
}
switch (propertyName.ToLowerInvariant())
{
case "not":
var filter = serializer.Deserialize <FilterNode <IJsonValue> >(reader);
result = new NegateFilter <IJsonValue>(filter);
break;
case "and":
var andFilters = serializer.Deserialize <List <FilterNode <IJsonValue> > >(reader);
result = new LogicalFilter <IJsonValue>(LogicalFilterType.And, andFilters);
break;
case "or":
var orFilters = serializer.Deserialize <List <FilterNode <IJsonValue> > >(reader);
result = new LogicalFilter <IJsonValue>(LogicalFilterType.Or, orFilters);
break;
case "path":
comparePath = serializer.Deserialize <PropertyPath>(reader);
break;
case "op":
compareOperator = ReadOperator(reader, serializer);
break;
case "value":
compareValue = serializer.Deserialize <IJsonValue>(reader);
break;
}
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
if (result != null)
{
return(result);
}
if (comparePath == null)
{
throw new JsonSerializationException("Path not defined.");
}
if (compareValue == null && compareOperator != CompareOperator.Empty)
{
throw new JsonSerializationException("Value not defined.");
}
if (!compareOperator.IsEnumValue())
{
throw new JsonSerializationException("Operator not defined.");
}
return(new CompareFilter <IJsonValue>(comparePath, compareOperator, compareValue ?? JsonValue.Null));
}
}
throw new JsonSerializationException("Unexpected end when reading filter.");
}
public virtual T Visit(NegateFilter <TValue> nodeIn, TArgs args)
{
throw new NotImplementedException();
}
public override FilterNode <ClrValue> Visit(NegateFilter <IJsonValue> nodeIn)
{
return(new NegateFilter <ClrValue>(nodeIn.Accept(this)));
}
