public static TResult Match <TResult>(
this CombinationOperator @operator,
Func <TResult> allPredicate,
Func <TResult> anyPredicate)
=> @operator == CombinationOperator.All
? allPredicate()
: anyPredicate();
public Selector(string field, CombinationOperator combinationOperator, object value)
{
this.Field = field;
this.CombinationOp = combinationOperator;
this.Value = value;
ValidateCombinationOperator();
}
public static TResult Match <TResult>(
this CombinationOperator @operator,
TResult allResult,
TResult anyResult)
=> @operator == CombinationOperator.All
? allResult
: anyResult;
private static Func <TItemToTest, bool> Combine <TItemToTest>(
Func <TItemToTest, bool>[] innerResults,
CombinationOperator @operator)
{
Func <TItemToTest, bool> AllReducer()
=> relatedItemCollection =>
{
for (var i = 0; i < innerResults.Length; i++)
{
if (!innerResults[i](relatedItemCollection))
{
return(false);
}
}
return(true);
};
Func <TItemToTest, bool> AnyReducer()
=> relatedItemCollection =>
{
for (var i = 0; i < innerResults.Length; i++)
{
if (innerResults[i](relatedItemCollection))
{
return(true);
}
}
return(false);
};
return(@operator.Match(AllReducer, AnyReducer));
}
internal CombinationFilterNode(IFilterNode <TFilter>[] nodes, CombinationOperator @operator, bool isCollapsed, IComparer <IFilterNode <TFilter> > comparer)
{
IsCollapsed = isCollapsed;
Nodes = nodes;
Operator = @operator;
_nodesSet = new SimpleLazy <HashSet <IFilterNode> >(() => new HashSet <IFilterNode>(nodes));
_comparer = comparer;
}
public static TResult Match <TSource, TResult>(
this IEnumerable <TSource> source,
Func <IEnumerable <TSource>, TResult> allReducer,
Func <IEnumerable <TSource>, TResult> anyReducer,
CombinationOperator @operator = default)
=> @operator.Match(
() => allReducer(source),
() => anyReducer(source));
internal static Func <TItemToTest, bool> Combine <TItemToTest>(
IEnumerable <Func <TItemToTest, bool> > innerResults,
CombinationOperator @operator)
{
Func <TItemToTest, bool> AllReducer()
=> relatedItemCollection => innerResults.All(comparator => comparator(relatedItemCollection));
Func <TItemToTest, bool> AnyReducer()
=> relatedItemCollection => innerResults.Any(comparator => comparator(relatedItemCollection));
return(@operator.Match(AllReducer, AnyReducer));
}
/// <summary>
/// Combines the supplied <see cref="IFilterNode" />s into a <see cref="ICombinationFilterNode"/>,
/// or returns the node if there is only a single one.
/// </summary>
/// <typeparam name="TFilter"></typeparam>
public static IFilterNode <TFilter> Combine <TFilter>(
this IEnumerable <IFilterNode <TFilter> > filterNodes,
CombinationOperator @operator = default)
where TFilter : IFilter
{
var filterNodesArray = filterNodes.ToArray();
// Use the internal constructor for CombinationFilterNode to save calling ToArray again on filterNodes,
// which is done in the public constructors.
return(filterNodesArray.Length == 1
? filterNodesArray[0]
: new CombinationFilterNode <TFilter>(filterNodesArray, @operator, isCollapsed: false, comparer: null));
}
public IPredication Instantiate(IEnumerable <IPredication> predications, CombinationOperator combinationOperator)
{
switch (combinationOperator)
{
case CombinationOperator.Or:
return(new OrCombinationPredication(predications));
case CombinationOperator.XOr:
return(new XOrCombinationPredication(predications));
case CombinationOperator.And:
return(new AndCombinationPredication(predications));
default:
throw new ArgumentOutOfRangeException(nameof(combinationOperator));
}
}
public void Collapse_ShouldAbsorbRedundantNestedCombinations(CombinationOperator outerCombinationOperator, CombinationOperator alternateInnerCombinationOperator)
{
var filterA = new CharFilter('A');
var filterB = new CharFilter('B');
var filterC = new CharFilter('C');
var filterD = new CharFilter('D');
var filterE = new CharFilter('E');
var filterF = new CharFilter('F');
var filterG = new CharFilter('G');
var filterH = new CharFilter('H');
var innerCombinationFilterToFlatten = new CombinationFilterNode <CharFilter>(new[] { filterA, filterB }, outerCombinationOperator);
var innerCombinationFilterToRetain = new CombinationFilterNode <CharFilter>(new[] { filterC, filterD }, alternateInnerCombinationOperator);
var innerCombinationFilterToAbsorb = new CombinationFilterNode <CharFilter>(new[] { filterA, filterE }, alternateInnerCombinationOperator);
var outerCombinationFilter = new CombinationFilterNode <CharFilter>(new IFilterNode <CharFilter>[]
{
innerCombinationFilterToFlatten,
innerCombinationFilterToRetain,
innerCombinationFilterToAbsorb,
filterG.ToLeafFilterNode(),
filterH.ToLeafFilterNode()
}, outerCombinationOperator);
var collapsedFilter = outerCombinationFilter.Collapse();
var expectedCollapsedFilter = new CombinationFilterNode <CharFilter>(new IFilterNode <CharFilter>[]
{
filterA.ToLeafFilterNode(),
filterB.ToLeafFilterNode(),
innerCombinationFilterToRetain,
filterG.ToLeafFilterNode(),
filterH.ToLeafFilterNode(),
}, outerCombinationOperator);
Assert.Equal(expectedCollapsedFilter, collapsedFilter);
// Also check IsEquivalentTo works, which internally uses Collapse.
Assert.True(collapsedFilter.IsEquivalentTo(outerCombinationFilter));
Assert.True(outerCombinationFilter.IsEquivalentTo(collapsedFilter));
}
public void Collapse_ShouldFlattenNestedCombinations_WhenInnerOperatorMatchesOuter(CombinationOperator outerCombinationOperator, CombinationOperator alternateInnerCombinationOperator)
{
var filterA = new CharFilter('A');
var filterB = new CharFilter('B');
var filterC = new CharFilter('C');
var filterD = new CharFilter('D');
var filterE = new CharFilter('E');
var filterF = new CharFilter('F');
var filterG = new CharFilter('G');
var filterH = new CharFilter('H');
var innerCombinationFilterToFlatten = new CombinationFilterNode <CharFilter>(new [] { filterA, filterB }, outerCombinationOperator);
var innerCombinationFilterToRetain1 = new CombinationFilterNode <CharFilter>(new [] { filterC, filterD }, alternateInnerCombinationOperator);
var innerCombinationFilterToRetain2 = new CombinationFilterNode <CharFilter>(new[] { filterE, filterF }, alternateInnerCombinationOperator);
// When outer operator == All and other == Any, this is equivalent to
// (A AND B) AND (C OR D) AND (E OR F) AND G AND H
// Which can be collapsed to: A AND B AND G AND H AND (C OR D) AND (E OR F)
// When outer operator == Any and other == All, this is equivalent to
// (A OR B) OR (C AND D) OR (E AND F) OR G OR H
// Which can be collapsed to: A OR B OR G OR H OR (C AND D) OR (E AND F)
var outerCombinationFilter = new CombinationFilterNode <CharFilter>(new IFilterNode <CharFilter>[]
{
innerCombinationFilterToFlatten,
innerCombinationFilterToRetain1,
innerCombinationFilterToRetain2,
filterG.ToLeafFilterNode(),
filterH.ToLeafFilterNode()
}, outerCombinationOperator);
var collapsedFilter = outerCombinationFilter.Collapse();
var expectedCollapsedFilter = new CombinationFilterNode <CharFilter>(new IFilterNode <CharFilter>[]
{
filterA.ToLeafFilterNode(),
filterB.ToLeafFilterNode(),
innerCombinationFilterToRetain1,
innerCombinationFilterToRetain2,
filterG.ToLeafFilterNode(),
filterH.ToLeafFilterNode(),
}, outerCombinationOperator);
Assert.Equal(expectedCollapsedFilter, collapsedFilter);
// Also check IsEquivalentTo works, which internally uses Collapse.
Assert.True(collapsedFilter.IsEquivalentTo(outerCombinationFilter));
Assert.True(outerCombinationFilter.IsEquivalentTo(collapsedFilter));
}
public CombinationFilter(IImmutableSet <IFilterNode <TLeafNode> > filters, CombinationOperator @operator = default)
: base(filters, @operator)
{
_filters = filters;
}
public CombinationFilterNode(IEnumerable <TFilter> filters, CombinationOperator @operator = default)
: this(filters.Select(f => f.ToLeafFilterNode()), @operator, isCollapsed : false, comparer : null)
{
}
public BasePredicateFilter Instantiate(IEnumerable <IColumnAlias> aliases, IEnumerable <IColumnExpression> expressions, CombinationOperator combinationOperator, IEnumerable <IPredicateInfo> predicateInfos)
{
var predications = new List <Predication>();
var factory = new PredicateFactory();
foreach (var predicateInfo in predicateInfos)
{
if (string.IsNullOrEmpty(predicateInfo.Operand))
{
throw new ArgumentException("You must specify an operand for a predicate. The operand is the column or alias or expression on which the predicate will be evaluated.");
}
var predicate = factory.Instantiate(predicateInfo);
predications.Add(new Predication(predicate, predicateInfo.Operand));
}
switch (combinationOperator)
{
case CombinationOperator.Or:
return(new OrCombinationPredicateFilter(aliases, expressions, predications));
case CombinationOperator.XOr:
return(new XOrCombinationPredicateFilter(aliases, expressions, predications));
case CombinationOperator.And:
return(new AndCombinationPredicateFilter(aliases, expressions, predications));
default:
throw new ArgumentOutOfRangeException(nameof(combinationOperator));
}
}
public OrderedCombinationFilter(IReadOnlyList <IFilterNode <TLeafNode> > filters, CombinationOperator @operator = default)
: base(filters, @operator)
{
}
public OrderedCombinationFilter(IEnumerable <IFilterNode <TLeafNode> > filters, CombinationOperator @operator = default)
: this(filters.ToList(), @operator)
{
}
public FindBuilder AddSelector(string field, CombinationOperator combinationOperator, object value)
{
this.selectors.Add(new Selector(field, combinationOperator, value));
return(this);
}
/// <summary>
/// Combines the supplied <see cref="IFilterNode" />s into a <see cref="ICombinationFilterNode"/>,
/// or returns the node if there is only a single one.
/// </summary>
/// <typeparam name="TFilter"></typeparam>
public static IFilterNode <TFilter> Combine <TFilter>(
this IEnumerable <TFilter> filters,
CombinationOperator @operator = default)
where TFilter : IFilter
=> filters.Select(filter => filter.ToLeafFilterNode()).Combine(@operator);
protected CombinationFilterBase(IReadOnlyCollection <IFilterNode <TLeafNode> > filters, CombinationOperator @operator = default)
: base(filters, @operator)
{
Filters = filters;
}
internal CombinationFilterNode(IEnumerable <IFilterNode <TFilter> > nodes, CombinationOperator @operator, bool isCollapsed, IComparer <IFilterNode <TFilter> > comparer)
: this(nodes.ToArray(), @operator, isCollapsed, comparer)
{
}
public CombinationFilterNode(IEnumerable <IFilterNode <TFilter> > nodes, CombinationOperator @operator = default)
: this(nodes, @operator, isCollapsed : false, comparer : null)
{
}
public CombinationFilter(IEnumerable <IFilterNode <TLeafNode> > filters, CombinationOperator @operator = default)
: this(filters.ToImmutableHashSet(), @operator)
{
}
