public override void SeekExact(long targetOrd)
{
int delta = (int)(targetOrd - OuterInstance.OrdBase - Ord_Renamed);
//System.out.println(" seek(ord) targetOrd=" + targetOrd + " delta=" + delta + " ord=" + ord + " ii=" + indexInterval);
if (delta < 0 || delta > OuterInstance.IndexInterval)
{
int idx = (int)((long)((ulong)targetOrd >> OuterInstance.IndexIntervalBits));
BytesRef @base = OuterInstance.IndexedTermsArray[idx];
//System.out.println(" do seek term=" + base.utf8ToString());
Ord_Renamed = idx << OuterInstance.IndexIntervalBits;
delta = (int)(targetOrd - Ord_Renamed);
TermsEnum.SeekStatus seekStatus = TermsEnum.SeekCeil(@base);
Debug.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
}
else
{
//System.out.println("seek w/in block");
}
while (--delta >= 0)
{
BytesRef br = TermsEnum.Next();
if (br == null)
{
Debug.Assert(false);
return;
}
Ord_Renamed++;
}
SetTerm();
Debug.Assert(Term_Renamed != null);
}
public override void VisitMatchingTerms(IndexReader reader, string fieldName, SimpleTerm.IMatchingTermVisitor mtv)
{
int prefixLength = prefix.Length;
Terms terms = MultiFields.GetTerms(reader, fieldName);
if (terms != null)
{
TermsEnum termsEnum = terms.GetEnumerator();
TermsEnum.SeekStatus status = termsEnum.SeekCeil(prefixRef);
BytesRef text;
if (status == TermsEnum.SeekStatus.FOUND)
{
text = prefixRef;
}
else if (status == TermsEnum.SeekStatus.NOT_FOUND)
{
text = termsEnum.Term;
}
else
{
text = null;
}
while (true)
{
if (text != null && StringHelper.StartsWith(text, prefixRef))
{
string textString = text.Utf8ToString();
Match matcher = pattern.Match(textString.Substring(prefixLength));
if (matcher.Success)
{
mtv.VisitMatchingTerm(new Term(fieldName, textString));
}
}
else
{
break;
}
if (termsEnum.MoveNext())
{
text = termsEnum.Term;
}
else
{
break;
}
}
}
}
public override void VisitMatchingTerms(IndexReader reader, string fieldName, IMatchingTermVisitor mtv)
{
/* inspired by PrefixQuery.rewrite(): */
Terms terms = MultiFields.GetTerms(reader, fieldName);
if (terms != null)
{
TermsEnum termsEnum = terms.GetIterator(null);
bool skip = false;
TermsEnum.SeekStatus status = termsEnum.SeekCeil(new BytesRef(Prefix));
if (status == TermsEnum.SeekStatus.FOUND)
{
mtv.VisitMatchingTerm(GetLucenePrefixTerm(fieldName));
}
else if (status == TermsEnum.SeekStatus.NOT_FOUND)
{
if (StringHelper.StartsWith(termsEnum.Term, prefixRef))
{
mtv.VisitMatchingTerm(new Term(fieldName, termsEnum.Term.Utf8ToString()));
}
else
{
skip = true;
}
}
else
{
// EOF
skip = true;
}
if (!skip)
{
while (true)
{
BytesRef text = termsEnum.Next();
if (text != null && StringHelper.StartsWith(text, prefixRef))
{
mtv.VisitMatchingTerm(new Term(fieldName, text.Utf8ToString()));
}
else
{
break;
}
}
}
}
}
public override void VisitMatchingTerms(IndexReader reader, string fieldName, IMatchingTermVisitor mtv)
{
/* check term presence in index here for symmetry with other SimpleTerm's */
Terms terms = MultiFields.GetTerms(reader, fieldName);
if (terms != null)
{
TermsEnum termsEnum = terms.GetEnumerator();
TermsEnum.SeekStatus status = termsEnum.SeekCeil(new BytesRef(TermText));
if (status == TermsEnum.SeekStatus.FOUND)
{
mtv.VisitMatchingTerm(GetLuceneTerm(fieldName));
}
}
}
public override void SeekExact(long targetOrd)
{
int delta = (int)(targetOrd - outerInstance.m_ordBase - ord);
//System.out.println(" seek(ord) targetOrd=" + targetOrd + " delta=" + delta + " ord=" + ord + " ii=" + indexInterval);
if (delta < 0 || delta > outerInstance.indexInterval)
{
int idx = (int)((long)((ulong)targetOrd >> outerInstance.indexIntervalBits));
BytesRef @base = outerInstance.m_indexedTermsArray[idx];
//System.out.println(" do seek term=" + base.utf8ToString());
ord = idx << outerInstance.indexIntervalBits;
delta = (int)(targetOrd - ord);
TermsEnum.SeekStatus seekStatus = termsEnum.SeekCeil(@base);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
}
}
else
{
//System.out.println("seek w/in block");
}
while (--delta >= 0)
{
BytesRef br = termsEnum.Next();
if (br == null)
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(false);
}
return;
}
ord++;
}
SetTerm();
if (Debugging.AssertsEnabled)
{
Debugging.Assert(term != null);
}
}
private void TestSavedTerms(IndexReader r, IList <BytesRef> terms)
{
Console.WriteLine("TEST: run " + terms.Count + " terms on reader=" + r);
IndexSearcher s = NewSearcher(r);
terms.Shuffle(Random);
TermsEnum termsEnum = MultiFields.GetTerms(r, "field").GetEnumerator();
bool failed = false;
for (int iter = 0; iter < 10 * terms.Count; iter++)
{
BytesRef term = terms[Random.Next(terms.Count)];
Console.WriteLine("TEST: search " + term);
long t0 = J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond; // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results
int count = s.Search(new TermQuery(new Term("field", term)), 1).TotalHits;
if (count <= 0)
{
Console.WriteLine(" FAILED: count=" + count);
failed = true;
}
long t1 = J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond; // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results
Console.WriteLine(" took " + (t1 - t0) + " millis");
TermsEnum.SeekStatus result = termsEnum.SeekCeil(term);
if (result != TermsEnum.SeekStatus.FOUND)
{
if (result == TermsEnum.SeekStatus.END)
{
Console.WriteLine(" FAILED: got END");
}
else
{
Console.WriteLine(" FAILED: wrong term: got " + termsEnum.Term);
}
failed = true;
}
}
Assert.IsFalse(failed);
}
private void TestSavedTerms(IndexReader r, IList <BytesRef> terms)
{
Console.WriteLine("TEST: run " + terms.Count + " terms on reader=" + r);
IndexSearcher s = NewSearcher(r);
terms = CollectionsHelper.Shuffle(terms);
TermsEnum termsEnum = MultiFields.GetTerms(r, "field").Iterator(null);
bool failed = false;
for (int iter = 0; iter < 10 * terms.Count; iter++)
{
BytesRef term = terms[Random().Next(terms.Count)];
Console.WriteLine("TEST: search " + term);
long t0 = Environment.TickCount;
int count = s.Search(new TermQuery(new Term("field", term)), 1).TotalHits;
if (count <= 0)
{
Console.WriteLine(" FAILED: count=" + count);
failed = true;
}
long t1 = Environment.TickCount;
Console.WriteLine(" took " + (t1 - t0) + " millis");
TermsEnum.SeekStatus result = termsEnum.SeekCeil(term);
if (result != TermsEnum.SeekStatus.FOUND)
{
if (result == TermsEnum.SeekStatus.END)
{
Console.WriteLine(" FAILED: got END");
}
else
{
Console.WriteLine(" FAILED: wrong term: got " + termsEnum.Term());
}
failed = true;
}
}
Assert.IsFalse(failed);
}
internal virtual long LookupTerm(BytesRef key)
{
try
{
TermsEnum.SeekStatus status = TermsEnum_Renamed.SeekCeil(key);
if (status == TermsEnum.SeekStatus.END)
{
return(-NumValues - 1);
}
else if (status == TermsEnum.SeekStatus.FOUND)
{
return(TermsEnum_Renamed.Ord());
}
else
{
return(-TermsEnum_Renamed.Ord() - 1);
}
}
catch (Exception)
{
throw;
}
}
internal virtual long LookupTerm(BytesRef key)
{
try
{
TermsEnum.SeekStatus status = termsEnum.SeekCeil(key);
if (status == TermsEnum.SeekStatus.END)
{
return(-numValues - 1);
}
else if (status == TermsEnum.SeekStatus.FOUND)
{
return(termsEnum.Ord);
}
else
{
return(-termsEnum.Ord - 1);
}
}
catch (Exception bogus) when(bogus.IsIOException())
{
throw RuntimeException.Create(bogus);
}
}
internal virtual long LookupTerm(BytesRef key)
{
try
{
TermsEnum.SeekStatus status = termsEnum.SeekCeil(key);
if (status == TermsEnum.SeekStatus.END)
{
return(-numValues - 1);
}
else if (status == TermsEnum.SeekStatus.FOUND)
{
return(termsEnum.Ord);
}
else
{
return(-termsEnum.Ord - 1);
}
}
catch (IOException bogus)
{
throw new Exception(bogus.ToString(), bogus);
}
}
public virtual void _run()
{
for (int iter = 0; iter < NUM_TEST_ITER; iter++)
{
FieldData field = fields[Random.Next(fields.Length)];
TermsEnum termsEnum = termsDict.GetTerms(field.fieldInfo.Name).GetIterator(null);
#pragma warning disable 612, 618
if (si.Codec is Lucene3xCodec)
#pragma warning restore 612, 618
{
// code below expects unicode sort order
continue;
}
int upto = 0;
// Test straight enum of the terms:
while (true)
{
BytesRef term = termsEnum.Next();
if (term == null)
{
break;
}
BytesRef expected = new BytesRef(field.terms[upto++].text2);
Assert.IsTrue(expected.BytesEquals(term), "expected=" + expected + " vs actual " + term);
}
Assert.AreEqual(upto, field.terms.Length);
// Test random seek:
TermData term2 = field.terms[Random.Next(field.terms.Length)];
TermsEnum.SeekStatus status = termsEnum.SeekCeil(new BytesRef(term2.text2));
Assert.AreEqual(status, TermsEnum.SeekStatus.FOUND);
Assert.AreEqual(term2.docs.Length, termsEnum.DocFreq);
if (field.omitTF)
{
this.VerifyDocs(term2.docs, term2.positions, TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.NONE), false);
}
else
{
this.VerifyDocs(term2.docs, term2.positions, termsEnum.DocsAndPositions(null, null), true);
}
// Test random seek by ord:
int idx = Random.Next(field.terms.Length);
term2 = field.terms[idx];
bool success = false;
try
{
termsEnum.SeekExact(idx);
success = true;
}
#pragma warning disable 168
catch (NotSupportedException uoe)
#pragma warning restore 168
{
// ok -- skip it
}
if (success)
{
Assert.AreEqual(status, TermsEnum.SeekStatus.FOUND);
Assert.IsTrue(termsEnum.Term.BytesEquals(new BytesRef(term2.text2)));
Assert.AreEqual(term2.docs.Length, termsEnum.DocFreq);
if (field.omitTF)
{
this.VerifyDocs(term2.docs, term2.positions, TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.NONE), false);
}
else
{
this.VerifyDocs(term2.docs, term2.positions, termsEnum.DocsAndPositions(null, null), true);
}
}
// Test seek to non-existent terms:
if (Verbose)
{
Console.WriteLine("TEST: seek non-exist terms");
}
for (int i = 0; i < 100; i++)
{
string text2 = TestUtil.RandomUnicodeString(Random) + ".";
status = termsEnum.SeekCeil(new BytesRef(text2));
Assert.IsTrue(status == TermsEnum.SeekStatus.NOT_FOUND || status == TermsEnum.SeekStatus.END);
}
// Seek to each term, backwards:
if (Verbose)
{
Console.WriteLine("TEST: seek terms backwards");
}
for (int i = field.terms.Length - 1; i >= 0; i--)
{
Assert.AreEqual(TermsEnum.SeekStatus.FOUND, termsEnum.SeekCeil(new BytesRef(field.terms[i].text2)), Thread.CurrentThread.Name + ": field=" + field.fieldInfo.Name + " term=" + field.terms[i].text2);
Assert.AreEqual(field.terms[i].docs.Length, termsEnum.DocFreq);
}
// Seek to each term by ord, backwards
for (int i = field.terms.Length - 1; i >= 0; i--)
{
try
{
termsEnum.SeekExact(i);
Assert.AreEqual(field.terms[i].docs.Length, termsEnum.DocFreq);
Assert.IsTrue(termsEnum.Term.BytesEquals(new BytesRef(field.terms[i].text2)));
}
#pragma warning disable 168
catch (NotSupportedException uoe)
#pragma warning restore 168
{
}
}
// Seek to non-existent empty-string term
status = termsEnum.SeekCeil(new BytesRef(""));
Assert.IsNotNull(status);
//Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, status);
// Make sure we're now pointing to first term
Assert.IsTrue(termsEnum.Term.BytesEquals(new BytesRef(field.terms[0].text2)));
// Test docs enum
termsEnum.SeekCeil(new BytesRef(""));
upto = 0;
do
{
term2 = field.terms[upto];
if (Random.Next(3) == 1)
{
DocsEnum docs;
DocsEnum docsAndFreqs;
DocsAndPositionsEnum postings;
if (!field.omitTF)
{
postings = termsEnum.DocsAndPositions(null, null);
if (postings != null)
{
docs = docsAndFreqs = postings;
}
else
{
docs = docsAndFreqs = TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.FREQS);
}
}
else
{
postings = null;
docsAndFreqs = null;
docs = TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.NONE);
}
Assert.IsNotNull(docs);
int upto2 = -1;
bool ended = false;
while (upto2 < term2.docs.Length - 1)
{
// Maybe skip:
int left = term2.docs.Length - upto2;
int doc;
if (Random.Next(3) == 1 && left >= 1)
{
int inc = 1 + Random.Next(left - 1);
upto2 += inc;
if (Random.Next(2) == 1)
{
doc = docs.Advance(term2.docs[upto2]);
Assert.AreEqual(term2.docs[upto2], doc);
}
else
{
doc = docs.Advance(1 + term2.docs[upto2]);
if (doc == DocIdSetIterator.NO_MORE_DOCS)
{
// skipped past last doc
if (Debugging.AssertsEnabled)
{
Debugging.Assert(upto2 == term2.docs.Length - 1);
}
ended = true;
break;
}
else
{
// skipped to next doc
if (Debugging.AssertsEnabled)
{
Debugging.Assert(upto2 < term2.docs.Length - 1);
}
if (doc >= term2.docs[1 + upto2])
{
upto2++;
}
}
}
}
else
{
doc = docs.NextDoc();
Assert.IsTrue(doc != -1);
upto2++;
}
Assert.AreEqual(term2.docs[upto2], doc);
if (!field.omitTF)
{
Assert.AreEqual(term2.positions[upto2].Length, postings.Freq);
if (Random.Next(2) == 1)
{
this.VerifyPositions(term2.positions[upto2], postings);
}
}
}
if (!ended)
{
Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, docs.NextDoc());
}
}
upto++;
} while (termsEnum.Next() != null);
Assert.AreEqual(upto, field.terms.Length);
}
}
private void TestRandomSeeks(IndexReader r, params string[] validTermStrings)
{
BytesRef[] validTerms = new BytesRef[validTermStrings.Length];
for (int termIDX = 0; termIDX < validTermStrings.Length; termIDX++)
{
validTerms[termIDX] = new BytesRef(validTermStrings[termIDX]);
}
Array.Sort(validTerms);
if (VERBOSE)
{
Console.WriteLine("TEST: " + validTerms.Length + " terms:");
foreach (BytesRef t in validTerms)
{
Console.WriteLine(" " + t.Utf8ToString() + " " + t);
}
}
TermsEnum te = MultiFields.GetTerms(r, FIELD).GetIterator(null);
int END_LOC = -validTerms.Length - 1;
IList <TermAndState> termStates = new List <TermAndState>();
for (int iter = 0; iter < 100 * RANDOM_MULTIPLIER; iter++)
{
BytesRef t;
int loc;
TermState termState;
if (Random.Next(6) == 4)
{
// pick term that doens't exist:
t = GetNonExistTerm(validTerms);
termState = null;
if (VERBOSE)
{
Console.WriteLine("\nTEST: invalid term=" + t.Utf8ToString());
}
loc = Array.BinarySearch(validTerms, t);
}
else if (termStates.Count != 0 && Random.Next(4) == 1)
{
TermAndState ts = termStates[Random.Next(termStates.Count)];
t = ts.Term;
loc = Array.BinarySearch(validTerms, t);
Assert.IsTrue(loc >= 0);
termState = ts.State;
if (VERBOSE)
{
Console.WriteLine("\nTEST: valid termState term=" + t.Utf8ToString());
}
}
else
{
// pick valid term
loc = Random.Next(validTerms.Length);
t = BytesRef.DeepCopyOf(validTerms[loc]);
termState = null;
if (VERBOSE)
{
Console.WriteLine("\nTEST: valid term=" + t.Utf8ToString());
}
}
// seekCeil or seekExact:
bool doSeekExact = Random.NextBoolean();
if (termState != null)
{
if (VERBOSE)
{
Console.WriteLine(" seekExact termState");
}
te.SeekExact(t, termState);
}
else if (doSeekExact)
{
if (VERBOSE)
{
Console.WriteLine(" seekExact");
}
Assert.AreEqual(loc >= 0, te.SeekExact(t));
}
else
{
if (VERBOSE)
{
Console.WriteLine(" seekCeil");
}
TermsEnum.SeekStatus result = te.SeekCeil(t);
if (VERBOSE)
{
Console.WriteLine(" got " + result);
}
if (loc >= 0)
{
Assert.AreEqual(TermsEnum.SeekStatus.FOUND, result);
}
else if (loc == END_LOC)
{
Assert.AreEqual(TermsEnum.SeekStatus.END, result);
}
else
{
Debug.Assert(loc >= -validTerms.Length);
Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, result);
}
}
if (loc >= 0)
{
Assert.AreEqual(t, te.Term);
}
else if (doSeekExact)
{
// TermsEnum is unpositioned if seekExact returns false
continue;
}
else if (loc == END_LOC)
{
continue;
}
else
{
loc = -loc - 1;
Assert.AreEqual(validTerms[loc], te.Term);
}
// Do a bunch of next's after the seek
int numNext = Random.Next(validTerms.Length);
for (int nextCount = 0; nextCount < numNext; nextCount++)
{
if (VERBOSE)
{
Console.WriteLine("\nTEST: next loc=" + loc + " of " + validTerms.Length);
}
BytesRef t2 = te.Next();
loc++;
if (loc == validTerms.Length)
{
Assert.IsNull(t2);
break;
}
else
{
Assert.AreEqual(validTerms[loc], t2);
if (Random.Next(40) == 17 && termStates.Count < 100)
{
termStates.Add(new TermAndState(validTerms[loc], te.GetTermState()));
}
}
}
}
}
public virtual void Test()
{
Random random = new Random(Random.Next());
LineFileDocs docs = new LineFileDocs(random, DefaultCodecSupportsDocValues);
Directory d = NewDirectory();
MockAnalyzer analyzer = new MockAnalyzer(LuceneTestCase.Random);
analyzer.MaxTokenLength = TestUtil.NextInt32(LuceneTestCase.Random, 1, IndexWriter.MAX_TERM_LENGTH);
RandomIndexWriter w = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
LuceneTestCase.Random, d, analyzer);
int numDocs = AtLeast(10);
for (int docCount = 0; docCount < numDocs; docCount++)
{
w.AddDocument(docs.NextDoc());
}
IndexReader r = w.GetReader();
w.Dispose();
List <BytesRef> terms = new List <BytesRef>();
TermsEnum termsEnum = MultiFields.GetTerms(r, "body").GetIterator(null);
BytesRef term;
while ((term = termsEnum.Next()) != null)
{
terms.Add(BytesRef.DeepCopyOf(term));
}
if (VERBOSE)
{
Console.WriteLine("TEST: " + terms.Count + " terms");
}
int upto = -1;
int iters = AtLeast(200);
for (int iter = 0; iter < iters; iter++)
{
bool isEnd;
if (upto != -1 && LuceneTestCase.Random.NextBoolean())
{
// next
if (VERBOSE)
{
Console.WriteLine("TEST: iter next");
}
isEnd = termsEnum.Next() == null;
upto++;
if (isEnd)
{
if (VERBOSE)
{
Console.WriteLine(" end");
}
Assert.AreEqual(upto, terms.Count);
upto = -1;
}
else
{
if (VERBOSE)
{
Console.WriteLine(" got term=" + termsEnum.Term.Utf8ToString() + " expected=" + terms[upto].Utf8ToString());
}
Assert.IsTrue(upto < terms.Count);
Assert.AreEqual(terms[upto], termsEnum.Term);
}
}
else
{
BytesRef target;
string exists;
if (LuceneTestCase.Random.NextBoolean())
{
// likely fake term
if (LuceneTestCase.Random.NextBoolean())
{
target = new BytesRef(TestUtil.RandomSimpleString(LuceneTestCase.Random));
}
else
{
target = new BytesRef(TestUtil.RandomRealisticUnicodeString(LuceneTestCase.Random));
}
exists = "likely not";
}
else
{
// real term
target = terms[LuceneTestCase.Random.Next(terms.Count)];
exists = "yes";
}
upto = terms.BinarySearch(target);
if (LuceneTestCase.Random.NextBoolean())
{
if (VERBOSE)
{
Console.WriteLine("TEST: iter seekCeil target=" + target.Utf8ToString() + " exists=" + exists);
}
// seekCeil
TermsEnum.SeekStatus status = termsEnum.SeekCeil(target);
if (VERBOSE)
{
Console.WriteLine(" got " + status);
}
if (upto < 0)
{
upto = -(upto + 1);
if (upto >= terms.Count)
{
Assert.AreEqual(TermsEnum.SeekStatus.END, status);
upto = -1;
}
else
{
Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, status);
Assert.AreEqual(terms[upto], termsEnum.Term);
}
}
else
{
Assert.AreEqual(TermsEnum.SeekStatus.FOUND, status);
Assert.AreEqual(terms[upto], termsEnum.Term);
}
}
else
{
if (VERBOSE)
{
Console.WriteLine("TEST: iter seekExact target=" + target.Utf8ToString() + " exists=" + exists);
}
// seekExact
bool result = termsEnum.SeekExact(target);
if (VERBOSE)
{
Console.WriteLine(" got " + result);
}
if (upto < 0)
{
Assert.IsFalse(result);
upto = -1;
}
else
{
Assert.IsTrue(result);
Assert.AreEqual(target, termsEnum.Term);
}
}
}
}
r.Dispose();
d.Dispose();
docs.Dispose();
}
/// <exception cref="System.IO.IOException"></exception>
public virtual DocIdSet GetDocIdSet()
{
Debug.Assert(curVNode == null, "Called more than once?");
if (termsEnum == null)
{
return(null);
}
//advance
if ((thisTerm = termsEnum.Next()) == null)
{
return(null);
}
// all done
curVNode = new VNode(null);
curVNode.Reset(_enclosing.grid.WorldCell);
Start();
AddIntersectingChildren();
while (thisTerm != null)
{
//terminates for other reasons too!
//Advance curVNode pointer
if (curVNode.children != null)
{
//-- HAVE CHILDREN: DESCEND
Debug.Assert(curVNode.children.MoveNext());
//if we put it there then it has something
PreSiblings(curVNode);
curVNode = curVNode.children.Current;
}
else
{
//-- NO CHILDREN: ADVANCE TO NEXT SIBLING
VNode parentVNode = curVNode.parent;
while (true)
{
if (parentVNode == null)
{
goto main_break;
}
// all done
if (parentVNode.children.MoveNext())
{
//advance next sibling
curVNode = parentVNode.children.Current;
break;
}
else
{
//reached end of siblings; pop up
PostSiblings(parentVNode);
parentVNode.children = null;
//GC
parentVNode = parentVNode.parent;
}
}
}
//Seek to curVNode's cell (or skip if termsEnum has moved beyond)
curVNodeTerm.bytes = curVNode.cell.GetTokenBytes().ToSByteArray();
curVNodeTerm.length = curVNodeTerm.bytes.Length;
int compare = termsEnum.Comparator.Compare(thisTerm, curVNodeTerm
);
if (compare > 0)
{
// leap frog (termsEnum is beyond where we would otherwise seek)
Debug.Assert(
!((AtomicReader)context.Reader).Terms(_enclosing.fieldName).Iterator(null).SeekExact(
curVNodeTerm, false), "should be absent"
);
}
else
{
if (compare < 0)
{
// Seek !
TermsEnum.SeekStatus seekStatus = termsEnum.SeekCeil(curVNodeTerm, true
);
if (seekStatus == TermsEnum.SeekStatus.END)
{
break;
}
// all done
thisTerm = termsEnum.Term;
if (seekStatus == TermsEnum.SeekStatus.NOT_FOUND)
{
continue;
}
}
// leap frog
// Visit!
bool descend = Visit(curVNode.cell);
//advance
if ((thisTerm = termsEnum.Next()) == null)
{
break;
}
// all done
if (descend)
{
AddIntersectingChildren();
}
}
;
}
main_break:
;
//main loop
return(Finish());
}
public override SeekStatus SeekCeil(BytesRef target)
{
// already here
if (term != null && term.Equals(target))
{
return(SeekStatus.FOUND);
}
int startIdx = Array.BinarySearch(outerInstance.m_indexedTermsArray, target);
if (startIdx >= 0)
{
// we hit the term exactly... lucky us!
TermsEnum.SeekStatus seekStatus = termsEnum.SeekCeil(target);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
}
ord = startIdx << outerInstance.indexIntervalBits;
SetTerm();
if (Debugging.AssertsEnabled)
{
Debugging.Assert(term != null);
}
return(SeekStatus.FOUND);
}
// we didn't hit the term exactly
startIdx = -startIdx - 1;
if (startIdx == 0)
{
// our target occurs *before* the first term
TermsEnum.SeekStatus seekStatus = termsEnum.SeekCeil(target);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(seekStatus == TermsEnum.SeekStatus.NOT_FOUND);
}
ord = 0;
SetTerm();
if (Debugging.AssertsEnabled)
{
Debugging.Assert(term != null);
}
return(SeekStatus.NOT_FOUND);
}
// back up to the start of the block
startIdx--;
if ((ord >> outerInstance.indexIntervalBits) == startIdx && term != null && term.CompareTo(target) <= 0)
{
// we are already in the right block and the current term is before the term we want,
// so we don't need to seek.
}
else
{
// seek to the right block
TermsEnum.SeekStatus seekStatus = termsEnum.SeekCeil(outerInstance.m_indexedTermsArray[startIdx]);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
}
ord = startIdx << outerInstance.indexIntervalBits;
SetTerm();
if (Debugging.AssertsEnabled)
{
Debugging.Assert(term != null); // should be non-null since it's in the index
}
}
while (term != null && term.CompareTo(target) < 0)
{
Next();
}
if (term == null)
{
return(SeekStatus.END);
}
else if (term.CompareTo(target) == 0)
{
return(SeekStatus.FOUND);
}
else
{
return(SeekStatus.NOT_FOUND);
}
}
private void Verify(AtomicReader r, int[][] idToOrds, BytesRef[] termsArray, BytesRef prefixRef)
{
DocTermOrds dto = new DocTermOrds(r, r.LiveDocs, "field", prefixRef, int.MaxValue, TestUtil.NextInt32(Random, 2, 10));
FieldCache.Int32s docIDToID = FieldCache.DEFAULT.GetInt32s(r, "id", false);
/*
* for(int docID=0;docID<subR.MaxDoc;docID++) {
* System.out.println(" docID=" + docID + " id=" + docIDToID[docID]);
* }
*/
if (VERBOSE)
{
Console.WriteLine("TEST: verify prefix=" + (prefixRef == null ? "null" : prefixRef.Utf8ToString()));
Console.WriteLine("TEST: all TERMS:");
TermsEnum allTE = MultiFields.GetTerms(r, "field").GetIterator(null);
int ord = 0;
while (allTE.Next() != null)
{
Console.WriteLine(" ord=" + (ord++) + " term=" + allTE.Term.Utf8ToString());
}
}
//final TermsEnum te = subR.Fields.Terms("field").iterator();
TermsEnum te = dto.GetOrdTermsEnum(r);
if (dto.NumTerms == 0)
{
if (prefixRef == null)
{
Assert.IsNull(MultiFields.GetTerms(r, "field"));
}
else
{
Terms terms = MultiFields.GetTerms(r, "field");
if (terms != null)
{
TermsEnum termsEnum = terms.GetIterator(null);
TermsEnum.SeekStatus result = termsEnum.SeekCeil(prefixRef);
if (result != TermsEnum.SeekStatus.END)
{
Assert.IsFalse(StringHelper.StartsWith(termsEnum.Term, prefixRef), "term=" + termsEnum.Term.Utf8ToString() + " matches prefix=" + prefixRef.Utf8ToString());
}
else
{
// ok
}
}
else
{
// ok
}
}
return;
}
if (VERBOSE)
{
Console.WriteLine("TEST: TERMS:");
te.SeekExact(0);
while (true)
{
Console.WriteLine(" ord=" + te.Ord + " term=" + te.Term.Utf8ToString());
if (te.Next() == null)
{
break;
}
}
}
SortedSetDocValues iter = dto.GetIterator(r);
for (int docID = 0; docID < r.MaxDoc; docID++)
{
if (VERBOSE)
{
Console.WriteLine("TEST: docID=" + docID + " of " + r.MaxDoc + " (id=" + docIDToID.Get(docID) + ")");
}
iter.SetDocument(docID);
int[] answers = idToOrds[docIDToID.Get(docID)];
int upto = 0;
long ord;
while ((ord = iter.NextOrd()) != SortedSetDocValues.NO_MORE_ORDS)
{
te.SeekExact(ord);
BytesRef expected = termsArray[answers[upto++]];
if (VERBOSE)
{
Console.WriteLine(" exp=" + expected.Utf8ToString() + " actual=" + te.Term.Utf8ToString());
}
Assert.AreEqual(expected, te.Term, "expected=" + expected.Utf8ToString() + " actual=" + te.Term.Utf8ToString() + " ord=" + ord);
}
Assert.AreEqual(answers.Length, upto);
}
}
public override SeekStatus SeekCeil(BytesRef target)
{
// already here
if (Term_Renamed != null && Term_Renamed.Equals(target))
{
return(SeekStatus.FOUND);
}
int startIdx = OuterInstance.IndexedTermsArray.ToList().BinarySearch(target);
if (startIdx >= 0)
{
// we hit the term exactly... lucky us!
TermsEnum.SeekStatus seekStatus = TermsEnum.SeekCeil(target);
Debug.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
Ord_Renamed = startIdx << OuterInstance.IndexIntervalBits;
SetTerm();
Debug.Assert(Term_Renamed != null);
return(SeekStatus.FOUND);
}
// we didn't hit the term exactly
startIdx = -startIdx - 1;
if (startIdx == 0)
{
// our target occurs *before* the first term
TermsEnum.SeekStatus seekStatus = TermsEnum.SeekCeil(target);
Debug.Assert(seekStatus == TermsEnum.SeekStatus.NOT_FOUND);
Ord_Renamed = 0;
SetTerm();
Debug.Assert(Term_Renamed != null);
return(SeekStatus.NOT_FOUND);
}
// back up to the start of the block
startIdx--;
if ((Ord_Renamed >> OuterInstance.IndexIntervalBits) == startIdx && Term_Renamed != null && Term_Renamed.CompareTo(target) <= 0)
{
// we are already in the right block and the current term is before the term we want,
// so we don't need to seek.
}
else
{
// seek to the right block
TermsEnum.SeekStatus seekStatus = TermsEnum.SeekCeil(OuterInstance.IndexedTermsArray[startIdx]);
Debug.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
Ord_Renamed = startIdx << OuterInstance.IndexIntervalBits;
SetTerm();
Debug.Assert(Term_Renamed != null); // should be non-null since it's in the index
}
while (Term_Renamed != null && Term_Renamed.CompareTo(target) < 0)
{
Next();
}
if (Term_Renamed == null)
{
return(SeekStatus.END);
}
else if (Term_Renamed.CompareTo(target) == 0)
{
return(SeekStatus.FOUND);
}
else
{
return(SeekStatus.NOT_FOUND);
}
}
public virtual DocIdSet GetDocIdSet()
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(curVNode == null, "Called more than once?");
}
if (m_termsEnum == null)
{
return(null);
}
//advance
if (!m_termsEnum.MoveNext())
{
return(null);// all done
}
thisTerm = m_termsEnum.Term;
curVNode = new VNode(null);
curVNode.Reset(m_outerInstance.m_grid.WorldCell);
Start();
AddIntersectingChildren();
while (thisTerm != null)//terminates for other reasons too!
{
//Advance curVNode pointer
if (curVNode.children != null)
{
//-- HAVE CHILDREN: DESCEND
// LUCENENET NOTE: Must call this line before calling MoveNext()
// on the enumerator.
//if we put it there then it has something
PreSiblings(curVNode);
// LUCENENET IMPORTANT: Must not call this inline with Debug.Assert
// because the compiler removes Debug.Assert statements in release mode!!
bool hasNext = curVNode.children.MoveNext();
if (Debugging.AssertsEnabled)
{
Debugging.Assert(hasNext);
}
curVNode = curVNode.children.Current;
}
else
{
//-- NO CHILDREN: ADVANCE TO NEXT SIBLING
VNode parentVNode = curVNode.parent;
while (true)
{
if (parentVNode == null)
{
goto main_break;// all done
}
if (parentVNode.children.MoveNext())
{
//advance next sibling
curVNode = parentVNode.children.Current;
break;
}
else
{
//reached end of siblings; pop up
PostSiblings(parentVNode);
parentVNode.children = null;
//GC
parentVNode = parentVNode.parent;
}
}
}
//Seek to curVNode's cell (or skip if termsEnum has moved beyond)
curVNodeTerm.Bytes = curVNode.cell.GetTokenBytes();
curVNodeTerm.Length = curVNodeTerm.Bytes.Length;
int compare = m_termsEnum.Comparer.Compare(thisTerm, curVNodeTerm);
if (compare > 0)
{
// leap frog (termsEnum is beyond where we would otherwise seek)
if (Debugging.AssertsEnabled)
{
Debugging.Assert(!m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetEnumerator().SeekExact(curVNodeTerm), "should be absent");
}
}
else
{
if (compare < 0)
{
// Seek !
TermsEnum.SeekStatus seekStatus = m_termsEnum.SeekCeil(curVNodeTerm);
if (seekStatus == TermsEnum.SeekStatus.END)
{
break;// all done
}
thisTerm = m_termsEnum.Term;
if (seekStatus == TermsEnum.SeekStatus.NOT_FOUND)
{
continue; // leap frog
}
}
// Visit!
bool descend = Visit(curVNode.cell);
//advance
if (!m_termsEnum.MoveNext())
{
thisTerm = null;
break;// all done
}
thisTerm = m_termsEnum.Term;
if (descend)
{
AddIntersectingChildren();
}
}
;
}//main loop
main_break : { }
return(Finish());
}
