public void Test1()
{
var parser = new FiltersParser();
var fastCollection = new FastCollection <TestClassA>();
var parsed = parser.ParsePredicate((TestClassA x) => x.F1 > 3, OperationTargetBuilder.BuildForRoot(fastCollection));
Assert.IsAssignableFrom <ComparisonFilter>(parsed);
Assert.AreEqual(ComparisonFilterType.Greater, ((ComparisonFilter)parsed).ComparisonFilterType);
Assert.AreEqual(3, ((ComparisonFilter)parsed).Value);
Assert.AreSame(fastCollection, ((ComparisonFilter)parsed).OperationTarget.RootFastCollection);
}
public void Test2()
{
// Embedded in predicate fast collection. Not in current version
var parser = new FiltersParser();
var fastCollection = new FastCollection <TestClassA>();
//var parsed = parser.ParsePredicate((TestClassA x) => fastCollection.Where(y => y.F1 > 4).Select(y => y.F1).Contains(x.F1), OperationTargetBuilder.BuildForRoot(fastCollection));
// Assert.IsAssignableFrom<ComparisonFilter>(parsed);
// Assert.AreEqual(ComparisonFilterType.Greater, ((ComparisonFilter)parsed).ComparisonFilterType);
// Assert.AreEqual(3, ((ComparisonFilter)parsed).Value);
// Assert.AreSame(fastCollection, ((ComparisonFilter)parsed).OperationTarget.RootFastCollection);
}
public void AndCompoundTest()
{
var parser = new FiltersParser();
var fastCollection = new FastCollection <TestClassA>();
var parsed = parser.ParsePredicate((TestClassA x) => (x.F1 > 3) && (x.F1 <= 10), OperationTargetBuilder.BuildForRoot(fastCollection));
Assert.IsAssignableFrom <CompoundFilter>(parsed);
Assert.AreEqual(CompoundFilter.CompoundFilterType.And, ((CompoundFilter)parsed).OperationType);
var filter1 = (ComparisonFilter)((CompoundFilter)parsed).Operands.ElementAt(0);
Assert.AreEqual(ComparisonFilterType.Greater, filter1.ComparisonFilterType);
Assert.AreEqual(3, filter1.Value);
var filter2 = (ComparisonFilter)((CompoundFilter)parsed).Operands.ElementAt(1);
Assert.AreEqual(ComparisonFilterType.LessOrEqual, filter2.ComparisonFilterType);
Assert.AreEqual(10, filter2.Value);
}
public static IFastCollectionEnumerable <TSource> Where <TSource>(
[NotNull] this IFastCollectionEnumerable <TSource> source,
[NotNull] Expression <Func <TSource, bool> > predicate)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
var sourceIterator = source.ExtractIterator();
var filter = new FiltersParser().ParsePredicate(predicate, sourceIterator.OperationTarget);
var filtersExecutor = new FiltersExecutor();
var preparedFilterExecution = filtersExecutor.PrepareExecution(filter, sourceIterator.SourceCollection.IndicesCoverage);
if (preparedFilterExecution.CanBeExecuted)
{
// We can use indices for execution
return(new FastCollectionLazyIterator <TSource>(
sourceIterator.SourceCollection,
sourceIterator.OperationTarget,
() =>
{
// This lambda will be called on items demand
var cuttedIds = new HashSet <int>(preparedFilterExecution.ExecuteAction());
return sourceIterator.ItemsEnumerable.Where(x => cuttedIds.Contains(x.Id));
}));
}
else
{
// In this case we can't use indices for execution and we have to check each item
var compiledPredicate = predicate.Compile();
var newItemsEnumerable = sourceIterator.ItemsEnumerable.Where(x => compiledPredicate(x.Data));
var fastCollectionWhereEnumerable = new FastCollectionIterator <TSource>(sourceIterator.SourceCollection, sourceIterator.OperationTarget, newItemsEnumerable);
return(fastCollectionWhereEnumerable);
}
}
