public static async Task <TResult> MatchAsync <TFilter, TResult>(
this IFilterNode <TFilter> node,
Func <ICombinationFilterNode <TFilter>, TResult> combine,
Func <IInvertedFilterNode <TFilter>, TResult> invert,
Func <ILeafFilterNode <TFilter>, Task <TResult> > transform)
{
switch (node)
{
case ICombinationFilterNode <TFilter> combinationNode:
return(combine(combinationNode));
case IInvertedFilterNode <TFilter> invertedNode:
return(invert(invertedNode));
case ILeafFilterNode <TFilter> leafNode:
return(await transform(leafNode).ConfigureAwait(false));
default:
throw new InvalidOperationException($"Unhandled {nameof(node)} of type: {node.GetType()}");
}
}
public static async Task <TResult> MatchAsync <TLeafNode, TResult>(
this IFilterNode <TLeafNode> filter,
Func <ICombinationFilterNode <TLeafNode>, TResult> combine,
Func <IInvertedFilter <TLeafNode>, TResult> invert,
Func <TLeafNode, Task <TResult> > transform)
where TLeafNode : class, ILeafFilterNode
{
switch (filter)
{
case ICombinationFilterNode <TLeafNode> combinationFilter:
return(combine(combinationFilter));
case IInvertedFilter <TLeafNode> invertedFilter:
return(invert(invertedFilter));
case TLeafNode leafFilter:
return(await transform(leafFilter));
default:
throw new InvalidOperationException($"Unhandled {nameof(filter)} of type: {filter.GetType()}");
}
}
public static async Task <IFilterNode <TResultLeafNode> > MapAsync <TLeafNode, TResultLeafNode>(
this IFilterNode <TLeafNode> filter,
Func <TLeafNode, Task <TResultLeafNode> > mapFunc)
where TLeafNode : class, ILeafFilterNode
where TResultLeafNode : class, ILeafFilterNode <TResultLeafNode>
{
switch (filter)
{
case ICombinationFilterNode <TLeafNode> combinationFilter:
var innerFilterTasks = combinationFilter.Filters.Select(f => f.MapAsync(mapFunc));
var innerFilters = await Task.WhenAll(innerFilterTasks);
return(new CombinationFilter <TResultLeafNode>(innerFilters, combinationFilter.Operator));
case IInvertedFilter <TLeafNode> invertedFilter:
var innerFilter = await invertedFilter.FilterToInvert.MapAsync(mapFunc);
return(new InvertedFilter <TResultLeafNode>(innerFilter));
case TLeafNode leafFilter:
return(await mapFunc(leafFilter));
default:
throw new InvalidOperationException($"Unhandled {nameof(filter)} of type: {filter.GetType()}");
}
}
public static async Task <IFilterNode <TResultFilter> > MapAsync <TFilter, TResultFilter>(
this IFilterNode <TFilter> filter,
Func <TFilter, Task <TResultFilter> > mapFunc)
where TFilter : IFilter
where TResultFilter : IFilter
{
switch (filter)
{
case ICombinationFilterNode <TFilter> combinationFilter:
var innerNodesTasks = combinationFilter.Nodes.Select(f => f.MapAsync(mapFunc));
var innerNodes = await Task.WhenAll(innerNodesTasks).ConfigureAwait(false);
return(innerNodes.Combine(combinationFilter.Operator));
case IInvertedFilterNode <TFilter> invertedFilter:
var innerNodeToInvert = await invertedFilter.NodeToInvert.MapAsync(mapFunc).ConfigureAwait(false);
return(innerNodeToInvert.Invert());
case ILeafFilterNode <TFilter> leafFilter:
return((await mapFunc(leafFilter.Filter).ConfigureAwait(false)).ToLeafFilterNode());
default:
throw new InvalidOperationException($"Unhandled {nameof(filter)} of type: {filter.GetType()}");
}
}
