/*
* private class IterableAnonymousInnerClassHelper3 : IEnumerable<BytesRef>
* {
* private readonly DocValuesConsumer OuterInstance;
*
* private SortedDocValues[] Dvs;
* private OrdinalMap Map;
*
* public IterableAnonymousInnerClassHelper3(DocValuesConsumer outerInstance, SortedDocValues[] dvs, OrdinalMap map)
* {
* this.OuterInstance = outerInstance;
* this.Dvs = dvs;
* this.Map = map;
* }
*
* // ord -> value
* public virtual IEnumerator<BytesRef> GetEnumerator()
* {
* return new IteratorAnonymousInnerClassHelper3(this);
* }
*
* private class IteratorAnonymousInnerClassHelper3 : IEnumerator<BytesRef>
* {
* private readonly IterableAnonymousInnerClassHelper3 OuterInstance;
*
* public IteratorAnonymousInnerClassHelper3(IterableAnonymousInnerClassHelper3 outerInstance)
* {
* this.OuterInstance = outerInstance;
* scratch = new BytesRef();
* }
*
* internal readonly BytesRef scratch;
* internal int currentOrd;
*
* public virtual bool HasNext()
* {
* return currentOrd < OuterInstance.Map.ValueCount;
* }
*
* public virtual BytesRef Next()
* {
* if (!HasNext())
* {
* throw new Exception();
* }
* int segmentNumber = OuterInstance.Map.GetFirstSegmentNumber(currentOrd);
* int segmentOrd = (int)OuterInstance.Map.GetFirstSegmentOrd(currentOrd);
* OuterInstance.Dvs[segmentNumber].LookupOrd(segmentOrd, scratch);
* currentOrd++;
* return scratch;
* }
*
* public virtual void Remove()
* {
* throw new System.NotSupportedException();
* }
* }
* }
*
* private class IterableAnonymousInnerClassHelper4 : IEnumerable<Number>
* {
* private readonly DocValuesConsumer OuterInstance;
*
* private AtomicReader[] Readers;
* private SortedDocValues[] Dvs;
* private OrdinalMap Map;
*
* public IterableAnonymousInnerClassHelper4(DocValuesConsumer outerInstance, AtomicReader[] readers, SortedDocValues[] dvs, OrdinalMap map)
* {
* this.OuterInstance = outerInstance;
* this.Readers = readers;
* this.Dvs = dvs;
* this.Map = map;
* }
*
* public virtual IEnumerator<Number> GetEnumerator()
* {
* return new IteratorAnonymousInnerClassHelper4(this);
* }
*
* private class IteratorAnonymousInnerClassHelper4 : IEnumerator<Number>
* {
* private readonly IterableAnonymousInnerClassHelper4 OuterInstance;
*
* public IteratorAnonymousInnerClassHelper4(IterableAnonymousInnerClassHelper4 outerInstance)
* {
* this.OuterInstance = outerInstance;
* readerUpto = -1;
* }
*
* internal int readerUpto;
* internal int docIDUpto;
* internal int nextValue;
* internal AtomicReader currentReader;
* internal Bits currentLiveDocs;
* internal bool nextIsSet;
*
* public virtual bool HasNext()
* {
* return nextIsSet || SetNext();
* }
*
* public virtual void Remove()
* {
* throw new System.NotSupportedException();
* }
*
* public virtual Number Next()
* {
* if (!HasNext())
* {
* throw new NoSuchElementException();
* }
* Debug.Assert(nextIsSet);
* nextIsSet = false;
* // TODO make a mutable number
* return nextValue;
* }
*
* private bool SetNext()
* {
* while (true)
* {
* if (readerUpto == OuterInstance.Readers.Length)
* {
* return false;
* }
*
* if (currentReader == null || docIDUpto == currentReader.MaxDoc)
* {
* readerUpto++;
* if (readerUpto < OuterInstance.Readers.Length)
* {
* currentReader = OuterInstance.Readers[readerUpto];
* currentLiveDocs = currentReader.LiveDocs;
* }
* docIDUpto = 0;
* continue;
* }
*
* if (currentLiveDocs == null || currentLiveDocs.get(docIDUpto))
* {
* nextIsSet = true;
* int segOrd = OuterInstance.Dvs[readerUpto].GetOrd(docIDUpto);
* nextValue = segOrd == -1 ? - 1 : (int) OuterInstance.Map.GetGlobalOrd(readerUpto, segOrd);
* docIDUpto++;
* return true;
* }
*
* docIDUpto++;
* }
* }
* }
* }*/
/// <summary>
/// Merges the sortedset docvalues from <code>toMerge</code>.
/// <p>
/// The default implementation calls <seealso cref="#addSortedSetField"/>, passing
/// an Iterable that merges ordinals and values and filters deleted documents .
/// </summary>
public virtual void MergeSortedSetField(FieldInfo fieldInfo, MergeState mergeState, IList <SortedSetDocValues> toMerge)
{
AtomicReader[] readers = mergeState.Readers.ToArray();
SortedSetDocValues[] dvs = toMerge.ToArray();
// step 1: iterate thru each sub and mark terms still in use
TermsEnum[] liveTerms = new TermsEnum[dvs.Length];
for (int sub = 0; sub < liveTerms.Length; sub++)
{
AtomicReader reader = readers[sub];
SortedSetDocValues dv = dvs[sub];
Bits liveDocs = reader.LiveDocs;
if (liveDocs == null)
{
liveTerms[sub] = dv.TermsEnum();
}
else
{
LongBitSet bitset = new LongBitSet(dv.ValueCount);
for (int i = 0; i < reader.MaxDoc; i++)
{
if (liveDocs.Get(i))
{
dv.Document = i;
long ord;
while ((ord = dv.NextOrd()) != SortedSetDocValues.NO_MORE_ORDS)
{
bitset.Set(ord);
}
}
}
liveTerms[sub] = new BitsFilteredTermsEnum(dv.TermsEnum(), bitset);
}
}
// step 2: create ordinal map (this conceptually does the "merging")
OrdinalMap map = new OrdinalMap(this, liveTerms);
// step 3: add field
AddSortedSetField(fieldInfo, GetMergeSortedSetValuesEnumerable(map, dvs),
// doc -> ord count
GetMergeSortedSetDocToOrdCountEnumerable(readers, dvs),
// ords
GetMergeSortedSetOrdsEnumerable(readers, dvs, map)
);
}
/// <exception cref="System.IO.IOException"></exception>
public override void SetNextReader(AtomicReaderContext context)
{
if (segmentFacetCounts != null)
{
segmentResults.AddItem(((TermGroupFacetCollector.MV.SegmentResult)CreateSegmentResult
()));
}
groupFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(((AtomicReader)context.Reader
()), groupField);
facetFieldDocTermOrds = FieldCache.DEFAULT.GetDocTermOrds(((AtomicReader)context.
Reader()), facetField);
facetFieldNumTerms = (int)facetFieldDocTermOrds.GetValueCount();
if (facetFieldNumTerms == 0)
{
facetOrdTermsEnum = null;
}
else
{
facetOrdTermsEnum = facetFieldDocTermOrds.TermsEnum();
}
// [facetFieldNumTerms() + 1] for all possible facet values and docs not containing facet field
segmentFacetCounts = new int[facetFieldNumTerms + 1];
segmentTotalCount = 0;
segmentGroupedFacetHits.Clear();
foreach (GroupedFacetHit groupedFacetHit in groupedFacetHits)
{
int groupOrd = groupedFacetHit.groupValue == null ? -1 : groupFieldTermsIndex.LookupTerm
(groupedFacetHit.groupValue);
if (groupedFacetHit.groupValue != null && groupOrd < 0)
{
continue;
}
int facetOrd;
if (groupedFacetHit.facetValue != null)
{
if (facetOrdTermsEnum == null || !facetOrdTermsEnum.SeekExact(groupedFacetHit.facetValue
))
{
continue;
}
facetOrd = (int)facetOrdTermsEnum.Ord();
}
else
{
facetOrd = facetFieldNumTerms;
}
// (facetFieldDocTermOrds.numTerms() + 1) for all possible facet values and docs not containing facet field
int segmentGroupedFacetsIndex = groupOrd * (facetFieldNumTerms + 1) + facetOrd;
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
}
if (facetPrefix != null)
{
TermsEnum.SeekStatus seekStatus;
if (facetOrdTermsEnum != null)
{
seekStatus = facetOrdTermsEnum.SeekCeil(facetPrefix);
}
else
{
seekStatus = TermsEnum.SeekStatus.END;
}
if (seekStatus != TermsEnum.SeekStatus.END)
{
startFacetOrd = (int)facetOrdTermsEnum.Ord();
}
else
{
startFacetOrd = 0;
endFacetOrd = 0;
return;
}
BytesRef facetEndPrefix = BytesRef.DeepCopyOf(facetPrefix);
facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
seekStatus = facetOrdTermsEnum.SeekCeil(facetEndPrefix);
if (seekStatus != TermsEnum.SeekStatus.END)
{
endFacetOrd = (int)facetOrdTermsEnum.Ord();
}
else
{
endFacetOrd = facetFieldNumTerms;
}
}
else
{
// Don't include null...
startFacetOrd = 0;
endFacetOrd = facetFieldNumTerms + 1;
}
}
public override TermsEnum Iterator(TermsEnum reuse)
{
return(DocTermOrds.TermsEnum());
}
