public override SeekStatus SeekCeil(BytesRef text)
{
int ord = Values.LookupTerm(text);
if (ord >= 0)
{
CurrentOrd = ord;
Term_Renamed.Offset = 0;
// TODO: is there a cleaner way?
// term.bytes may be pointing to codec-private byte[]
// storage, so we must force new byte[] allocation:
Term_Renamed.Bytes = new sbyte[text.Length];
Term_Renamed.CopyBytes(text);
return(SeekStatus.FOUND);
}
else
{
CurrentOrd = -ord - 1;
if (CurrentOrd == Values.ValueCount)
{
return(SeekStatus.END);
}
else
{
// TODO: hmm can we avoid this "extra" lookup?:
Values.LookupOrd(CurrentOrd, Term_Renamed);
return(SeekStatus.NOT_FOUND);
}
}
}
public override int LookupTerm(BytesRef key)
{
Debug.Assert(key.IsValid());
int result = @in.LookupTerm(key);
Debug.Assert(result < valueCount);
Debug.Assert(key.IsValid());
return(result);
}
public override int LookupTerm(BytesRef key)
{
Debug.Assert(key.Valid);
int result = @in.LookupTerm(key);
Debug.Assert(result < ValueCount_Renamed);
Debug.Assert(key.Valid);
return(result);
}
public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
{
SortedDocValues fcsi = FieldCache.GetTermsIndex((context.AtomicReader), Field);
FixedBitSet bits = new FixedBitSet(fcsi.ValueCount);
for (int i = 0; i < Terms.Length; i++)
{
int ord = fcsi.LookupTerm(Terms[i]);
if (ord >= 0)
{
bits.Set(ord);
}
}
return(new FieldCacheDocIdSetAnonymousInnerClassHelper(this, context.Reader.MaxDoc, acceptDocs, fcsi, bits));
}
public override int LookupTerm(BytesRef key)
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(key.IsValid());
}
int result = @in.LookupTerm(key);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(result < valueCount);
}
if (Debugging.AssertsEnabled)
{
Debugging.Assert(key.IsValid());
}
return(result);
}
public override long LookupTerm(BytesRef key)
{
return(@in.LookupTerm(key));
}
/// <exception cref="System.IO.IOException"></exception>
public override void SetNextReader(AtomicReaderContext context)
{
if (segmentFacetCounts != null)
{
segmentResults.AddItem(((TermGroupFacetCollector.SV.SegmentResult)CreateSegmentResult
()));
}
groupFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(((AtomicReader)context.Reader
()), groupField);
facetFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(((AtomicReader)context.Reader
()), facetField);
// 1+ to allow for the -1 "not set":
segmentFacetCounts = new int[facetFieldTermsIndex.GetValueCount() + 1];
segmentTotalCount = 0;
segmentGroupedFacetHits.Clear();
foreach (GroupedFacetHit groupedFacetHit in groupedFacetHits)
{
int facetOrd = groupedFacetHit.facetValue == null ? -1 : facetFieldTermsIndex.LookupTerm
(groupedFacetHit.facetValue);
if (groupedFacetHit.facetValue != null && facetOrd < 0)
{
continue;
}
int groupOrd = groupedFacetHit.groupValue == null ? -1 : groupFieldTermsIndex.LookupTerm
(groupedFacetHit.groupValue);
if (groupedFacetHit.groupValue != null && groupOrd < 0)
{
continue;
}
int segmentGroupedFacetsIndex = groupOrd * (facetFieldTermsIndex.GetValueCount()
+ 1) + facetOrd;
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
}
if (facetPrefix != null)
{
startFacetOrd = facetFieldTermsIndex.LookupTerm(facetPrefix);
if (startFacetOrd < 0)
{
// Points to the ord one higher than facetPrefix
startFacetOrd = -startFacetOrd - 1;
}
BytesRef facetEndPrefix = BytesRef.DeepCopyOf(facetPrefix);
facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
endFacetOrd = facetFieldTermsIndex.LookupTerm(facetEndPrefix);
endFacetOrd < 0 = -endFacetOrd - 1;
}
else
{
// Points to the ord one higher than facetEndPrefix
startFacetOrd = -1;
endFacetOrd = facetFieldTermsIndex.GetValueCount();
}
}
