public static BaseFilter operator |(BaseFilter leftFilter, BaseFilter rightFilter)
{
var defaultFilter = new BaseFilter()
{
IsConditionless = true
};
leftFilter = leftFilter ?? defaultFilter;
rightFilter = rightFilter ?? defaultFilter;
var combined = new[] { leftFilter, rightFilter };
if (combined.Any(bf => bf.IsConditionless))
{
return(combined.FirstOrDefault(bf => !bf.IsConditionless) ?? defaultFilter);
}
var leftBoolFilter = leftFilter.BoolFilterDescriptor;
var rightBoolFilter = rightFilter.BoolFilterDescriptor;
var f = new BaseFilter();
var fq = new BoolBaseFilterDescriptor();
fq._ShouldFilters = new[] { leftFilter, rightFilter };
f.BoolFilterDescriptor = fq;
//if neither the left nor the right side represent a bool filter join them
if (leftFilter.BoolFilterDescriptor == null && rightFilter.BoolFilterDescriptor == null)
{
fq._ShouldFilters = leftFilter.MergeShouldFilters(rightFilter);
return(f);
}
//if the left or right sight already is a bool filter determine join the non bool query side of the
//of the operation onto the other.
if (leftFilter.BoolFilterDescriptor != null && rightFilter.BoolFilterDescriptor == null && !leftFilter.IsStrict)
{
JoinShouldOnSide(leftFilter, rightFilter, fq);
}
else if (rightFilter.BoolFilterDescriptor != null && leftFilter.BoolFilterDescriptor == null && !rightFilter.IsStrict)
{
JoinShouldOnSide(rightFilter, leftFilter, fq);
}
//both sides already represent a bool filter
else
{
//both sides report that we may merge the shoulds
if (!leftFilter.IsStrict && !rightFilter.IsStrict &&
leftBoolFilter.CanJoinShould() &&
rightBoolFilter.CanJoinShould())
{
fq._ShouldFilters = leftFilter.MergeShouldFilters(rightFilter);
}
else
{
//create a new nested bool with two separate should bool sections
fq._ShouldFilters = new[] { leftFilter, rightFilter }
};
}
return(f);
}
internal static bool CanJoinShould(this BoolBaseFilterDescriptor bq)
{
return(bq == null ||
(
(bq._ShouldFilters.HasAny() && !bq._MustFilters.HasAny() && !bq._MustNotFilters.HasAny()) ||
!bq._ShouldFilters.HasAny()
));
}
public static BaseFilter operator !(BaseFilter lbq)
{
var f = new BaseFilter();
var fq = new BoolBaseFilterDescriptor();
fq._MustNotFilters = new[] { lbq };
f.BoolFilterDescriptor = fq;
return(f);
}
public static BaseFilter operator |(BaseFilter lbq, BaseFilter rbq)
{
if (lbq.IsConditionless && rbq.IsConditionless)
{
return new BaseFilter()
{
IsConditionless = true
}
}
;
else if (lbq.IsConditionless)
{
return(rbq);
}
else if (rbq.IsConditionless)
{
return(lbq);
}
var f = new BaseFilter();
var fq = new BoolBaseFilterDescriptor();
fq._ShouldFilters = new[] { lbq, rbq };
f.BoolFilterDescriptor = fq;
if (lbq.BoolFilterDescriptor == null && rbq.BoolFilterDescriptor == null)
{
fq._ShouldFilters = lbq.MergeShouldFilters(rbq);
return(f);
}
else if (lbq.BoolFilterDescriptor != null && rbq.BoolFilterDescriptor == null)
{
JoinShouldOnSide(lbq, rbq, fq);
}
else if (rbq.BoolFilterDescriptor != null && lbq.BoolFilterDescriptor == null)
{
JoinShouldOnSide(rbq, lbq, fq);
}
else
{
if (lbq.BoolFilterDescriptor.CanJoinShould() && rbq.BoolFilterDescriptor.CanJoinShould())
{
fq._ShouldFilters = lbq.MergeShouldFilters(rbq);
}
else
{
fq._ShouldFilters = new[] { lbq, rbq }
};
}
return(f);
}
public static FilterContainer CreateReturnFilter(Action <FilterContainer, BoolBaseFilterDescriptor> modify = null)
{
var returnFilter = new FilterContainer();
var returnBoolFilter = new BoolBaseFilterDescriptor()
{
};
((IFilterContainer)returnFilter).Bool = returnBoolFilter;
if (modify != null)
{
modify(returnFilter, returnBoolFilter);
}
return(returnFilter);
}
public static BaseFilter CreateReturnFilter(Action <BaseFilter, BoolBaseFilterDescriptor> modify = null)
{
var returnFilter = new BaseFilter();
var returnBoolFilter = new BoolBaseFilterDescriptor()
{
};
returnFilter.BoolFilterDescriptor = returnBoolFilter;
if (modify != null)
{
modify(returnFilter, returnBoolFilter);
}
return(returnFilter);
}
public static BaseFilter operator !(BaseFilter lbq)
{
if (lbq.IsConditionless)
{
return new BaseFilter {
IsConditionless = true
}
}
;
var f = new BaseFilter();
var fq = new BoolBaseFilterDescriptor();
fq._MustNotFilters = new[] { lbq };
f.BoolFilterDescriptor = fq;
return(f);
}
public static FilterContainer operator !(FilterContainer lbq)
{
if (lbq == null || lbq.IsConditionless)
{
return new FilterContainer {
IsConditionless = true
}
}
;
var f = new FilterContainer();
var fq = new BoolBaseFilterDescriptor();
((IBoolFilter)fq).MustNot = new[] { lbq };
((IFilterContainer)f).Bool = fq;
return(f);
}
public static BaseFilter operator &(BaseFilter lbq, BaseFilter rbq)
{
if (lbq.IsConditionless && rbq.IsConditionless)
{
return new BaseFilter()
{
IsConditionless = true
}
}
;
else if (lbq.IsConditionless)
{
return(rbq);
}
else if (rbq.IsConditionless)
{
return(lbq);
}
var f = new BaseFilter();
var fq = new BoolBaseFilterDescriptor();
f.BoolFilterDescriptor = fq;
if (lbq.BoolFilterDescriptor == null && rbq.BoolFilterDescriptor == null)
{
fq._MustFilters = new[] { lbq, rbq };
return(f);
}
if (lbq.BoolFilterDescriptor != null && rbq.BoolFilterDescriptor != null)
{
if (lbq.BoolFilterDescriptor._HasOnlyMustNot() && rbq.BoolFilterDescriptor._HasOnlyMustNot())
{
fq._MustFilters = null;
fq._MustNotFilters = lbq.MergeMustNotFilters(rbq);
}
else if (lbq.BoolFilterDescriptor.CanJoinMust() && rbq.BoolFilterDescriptor.CanJoinMust())
{
fq._MustFilters = lbq.MergeMustFilters(rbq);
}
else
{
fq._MustFilters = new[] { lbq, rbq }
};
if (lbq.BoolFilterDescriptor.CanJoinMustNot() && rbq.BoolFilterDescriptor.CanJoinMustNot())
{
fq._MustNotFilters = lbq.MergeMustNotFilters(rbq);
}
return(f);
}
if (lbq.BoolFilterDescriptor != null)
{
if (lbq.BoolFilterDescriptor._HasOnlyMustNot())
{
fq._MustNotFilters = lbq.BoolFilterDescriptor._MustNotFilters;
fq._MustFilters = new[] { rbq };
return(f);
}
else if (lbq.BoolFilterDescriptor.CanJoinMust())
{
fq._MustFilters = lbq.MergeMustFilters(rbq);
}
else
{
fq._MustFilters = new[] { lbq, rbq }
};
if (lbq.BoolFilterDescriptor.CanJoinMustNot())
{
fq._MustNotFilters = lbq.MergeMustNotFilters(rbq);
}
return(f);
}
if (rbq.BoolFilterDescriptor._HasOnlyMustNot())
{
fq._MustNotFilters = rbq.BoolFilterDescriptor._MustNotFilters;
fq._MustFilters = new[] { lbq };
return(f);
}
if (rbq.BoolFilterDescriptor.CanJoinMust())
{
fq._MustFilters = rbq.MergeMustFilters(lbq);
}
else
{
fq._MustFilters = new[] { rbq, lbq }
};
if (rbq.BoolFilterDescriptor.CanJoinMustNot())
{
fq._MustNotFilters = rbq.MergeMustNotFilters(lbq);
}
return(f);
}
private static void JoinShouldOnSide(BaseFilter lbq, BaseFilter rbq, BoolBaseFilterDescriptor bq)
{
bq._ShouldFilters = lbq.MergeShouldFilters(rbq);
}
internal static bool CanMergeMustAndMustNots(this BoolBaseFilterDescriptor bq)
{
return(bq == null || !bq._ShouldFilters.HasAny());
}
internal static bool CanJoinShould(this BoolBaseFilterDescriptor bq)
{
return(bq == null || (bq != null && bq._CanJoinShould()));
}
