private IAbstractAllGroupsCollector <object> CreateRandomCollector(string groupField, bool canUseIDV)
{
IAbstractAllGroupsCollector <object> selected;
if (Random.nextBoolean())
{
selected = new TermAllGroupsCollector(groupField);
}
else
{
ValueSource vs = new BytesRefFieldSource(groupField);
selected = new FunctionAllGroupsCollector(vs, new Hashtable());
}
if (VERBOSE)
{
Console.WriteLine("Selected implementation: " + selected.GetType().Name);
}
return(selected);
}
private IAbstractAllGroupsCollector <object> CreateRandomCollector(string groupField, bool canUseIDV)
{
IAbstractAllGroupsCollector <object> selected;
if (Random.nextBoolean())
{
selected = new TermAllGroupsCollector(groupField);
}
else
{
ValueSource vs = new BytesRefFieldSource(groupField);
selected = new FunctionAllGroupsCollector <MutableValue>(vs, new Hashtable()); // LUCENENET Specific type for generic must be specified.
}
if (Verbose)
{
Console.WriteLine("Selected implementation: " + selected.GetType().Name);
}
return(selected);
}
//LUCENENET Specific. One of two methods that replace GroupByFieldOrFunction. Used support
// SearchByFunction in a way that eliminates casting for the caller.
// This method is essentually a Function specific version of the GroupByFieldOrFunction.
protected virtual ITopGroups <TMutableValue> GroupByFunction <TMutableValue>(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit)
where TMutableValue : MutableValue
{
int topN = groupOffset + groupLimit;
FunctionFirstPassGroupingCollector <TMutableValue> firstPassCollector;
FunctionAllGroupsCollector <TMutableValue> allGroupsCollector;
AbstractAllGroupHeadsCollector allGroupHeadsCollector;
if (groupFunction == null)
{
throw IllegalStateException.Create("groupFunction must be set via the constructor by specifying a ValueSource.");
}
firstPassCollector = new FunctionFirstPassGroupingCollector <TMutableValue>(groupFunction, valueSourceContext, groupSort, topN);
if (allGroups)
{
allGroupsCollector = new FunctionAllGroupsCollector <TMutableValue>(groupFunction, valueSourceContext);
}
else
{
allGroupsCollector = null;
}
if (allGroupHeads)
{
allGroupHeadsCollector = new FunctionAllGroupHeadsCollector(groupFunction, valueSourceContext, sortWithinGroup);
}
else
{
allGroupHeadsCollector = null;
}
ICollector firstRound;
if (allGroupHeads || allGroups)
{
List <ICollector> collectors = new List <ICollector>();
collectors.Add(firstPassCollector);
if (allGroups)
{
collectors.Add(allGroupsCollector);
}
if (allGroupHeads)
{
collectors.Add(allGroupHeadsCollector);
}
firstRound = MultiCollector.Wrap(collectors.ToArray(/* new Collector[collectors.size()] */));
}
else
{
firstRound = firstPassCollector;
}
CachingCollector cachedCollector = null;
if (maxCacheRAMMB != null || maxDocsToCache != null)
{
if (maxCacheRAMMB != null)
{
cachedCollector = CachingCollector.Create(firstRound, cacheScores, maxCacheRAMMB.Value);
}
else
{
cachedCollector = CachingCollector.Create(firstRound, cacheScores, maxDocsToCache.Value);
}
searcher.Search(query, filter, cachedCollector);
}
else
{
searcher.Search(query, filter, firstRound);
}
if (allGroups)
{
matchingGroups = (ICollection)allGroupsCollector.Groups;
}
else
{
matchingGroups = (ICollection)Collections.EmptyList <TMutableValue>();
}
if (allGroupHeads)
{
matchingGroupHeads = allGroupHeadsCollector.RetrieveGroupHeads(searcher.IndexReader.MaxDoc);
}
else
{
matchingGroupHeads = new Bits.MatchNoBits(searcher.IndexReader.MaxDoc);
}
IEnumerable <ISearchGroup <TMutableValue> > topSearchGroups = firstPassCollector.GetTopGroups(groupOffset, fillSortFields);
if (topSearchGroups == null)
{
// LUCENENET specific - optimized empty array creation
return(new TopGroups <TMutableValue>(Arrays.Empty <SortField>(), Arrays.Empty <SortField>(), 0, 0, Arrays.Empty <GroupDocs <TMutableValue> >(), float.NaN));
}
int topNInsideGroup = groupDocsOffset + groupDocsLimit;
IAbstractSecondPassGroupingCollector <TMutableValue> secondPassCollector;
secondPassCollector = new FunctionSecondPassGroupingCollector <TMutableValue>(topSearchGroups as IEnumerable <ISearchGroup <TMutableValue> >,
groupSort, sortWithinGroup, topNInsideGroup, includeScores, includeMaxScore, fillSortFields, groupFunction, valueSourceContext)
as IAbstractSecondPassGroupingCollector <TMutableValue>;
if (cachedCollector != null && cachedCollector.IsCached)
{
cachedCollector.Replay(secondPassCollector);
}
else
{
searcher.Search(query, filter, secondPassCollector);
}
if (allGroups)
{
return(new TopGroups <TMutableValue>(secondPassCollector.GetTopGroups(groupDocsOffset), matchingGroups.Count));
}
else
{
return(secondPassCollector.GetTopGroups(groupDocsOffset));
}
}
private IAbstractAllGroupsCollector<object> CreateRandomCollector(string groupField, bool canUseIDV)
{
IAbstractAllGroupsCollector<object> selected;
if (Random().nextBoolean())
{
selected = new TermAllGroupsCollector(groupField);
}
else
{
ValueSource vs = new BytesRefFieldSource(groupField);
selected = new FunctionAllGroupsCollector(vs, new Hashtable());
}
if (VERBOSE)
{
Console.WriteLine("Selected implementation: " + selected.GetType().Name);
}
return selected;
}
