/// <summary>
/// Selects an asynchronous producer, for
/// the specified broker id and calls the send API on the selected
/// producer to publish the data to the specified broker partition.
/// </summary>
/// <param name="poolData">The producer pool request object.</param>
/// <remarks>
/// Used for multi-topic request
/// </remarks>
public override void Send(IEnumerable <ProducerPoolData <TData> > poolData)
{
this.EnsuresNotDisposed();
Guard.NotNull(poolData, "poolData");
Dictionary <int, List <ProducerPoolData <TData> > > distinctBrokers = poolData.GroupBy(
x => x.BidPid.BrokerId, x => x)
.ToDictionary(x => x.Key, x => x.ToList());
foreach (var broker in distinctBrokers)
{
Logger.DebugFormat(CultureInfo.CurrentCulture, "Fetching async producer for broker id: {0}", broker.Key);
IAsyncProducer producer;
if (!asyncProducers.TryGetValue(broker.Key, out producer))
{
var exception = new IllegalStateException(string.Format("Cannot find broker {0} in async producer collection", broker.Key));
exception.Data.Add("brokerId", broker.Key);
throw exception;
}
IEnumerable <ProducerRequest> requests = broker.Value.Select(x => new ProducerRequest(
x.Topic,
x.BidPid.PartId,
new BufferedMessageSet(x.Data.Select(y => this.Serializer.ToMessage(y)))));
foreach (var request in requests)
{
producer.Send(request);
}
}
}
/// <summary>
/// Commits final <see cref="T:byte[]"/>, trimming it if necessary and if <paramref name="trim"/>=true. </summary>
public Reader Freeze(bool trim)
{
if (frozen)
{
throw IllegalStateException.Create("already frozen");
}
if (didSkipBytes)
{
throw IllegalStateException.Create("cannot freeze when Copy(BytesRef, BytesRef) was used");
}
if (trim && upto < blockSize)
{
var newBlock = new byte[upto];
Array.Copy(currentBlock, 0, newBlock, 0, upto);
currentBlock = newBlock;
}
if (currentBlock == null)
{
currentBlock = EMPTY_BYTES;
}
blocks.Add(currentBlock);
blockEnd.Add(upto);
frozen = true;
currentBlock = null;
return(new PagedBytes.Reader(this));
}
/// <summary>
/// Detect mis-use, where provided parent query in fact sometimes returns child documents.
/// </summary>
private void ValidateParentDoc()
{
if (_parentDoc != NO_MORE_DOCS && !_parentBits.Get(_parentDoc))
{
throw IllegalStateException.Create(INVALID_QUERY_MESSAGE + _parentDoc);
}
}
/// <summary>
/// Call at most <see cref="numValues"/> times to encode a non decreasing sequence of non negative numbers. </summary>
/// <param name="x"> The next number to be encoded. </param>
/// <exception cref="InvalidOperationException"> when called more than <see cref="numValues"/> times. </exception>
/// <exception cref="ArgumentOutOfRangeException"> when:
/// <list type="bullet">
/// <item><description><paramref name="x"/> is smaller than an earlier encoded value, or</description></item>
/// <item><description><paramref name="x"/> is larger than <see cref="upperBound"/>.</description></item>
/// </list> </exception>
public virtual void EncodeNext(long x)
{
if (numEncoded >= numValues)
{
throw IllegalStateException.Create("EncodeNext() called more than " + numValues + " times.");
}
if (lastEncoded > x)
{
throw new ArgumentOutOfRangeException(nameof(x), x + " smaller than previous " + lastEncoded); // LUCENENET specific - changed from IllegalArgumentException to ArgumentOutOfRangeException (.NET convention)
}
if (x > upperBound)
{
throw new ArgumentOutOfRangeException(nameof(x), x + " larger than upperBound " + upperBound); // LUCENENET specific - changed from IllegalArgumentException to ArgumentOutOfRangeException (.NET convention)
}
long highValue = x.TripleShift(numLowBits);
EncodeUpperBits(highValue);
EncodeLowerBits(x & lowerBitsMask);
lastEncoded = x;
// Add index entries:
long indexValue = (currentEntryIndex + 1) * indexInterval;
while (indexValue <= highValue)
{
long afterZeroBitPosition = indexValue + numEncoded;
PackValue(afterZeroBitPosition, upperZeroBitPositionIndex, nIndexEntryBits, currentEntryIndex);
currentEntryIndex += 1;
indexValue += indexInterval;
}
numEncoded++;
}
/// <summary>
/// Start the update thread with the specified interval in milliseconds. For
/// debugging purposes, you can optionally set the name to set on
/// <see cref="ThreadJob.Name"/>. If you pass <c>null</c>, a default name
/// will be set.
/// </summary>
/// <exception cref="InvalidOperationException"> if the thread has already been started </exception>
public virtual void StartUpdateThread(long intervalInMilliseconds, string threadName)
{
UninterruptableMonitor.Enter(syncLock);
try
{
EnsureOpen();
if (updateThread != null && updateThread.IsAlive)
{
throw IllegalStateException.Create("cannot start an update thread when one is running, must first call 'stopUpdateThread()'");
}
threadName = threadName is null ? INFO_STREAM_COMPONENT : "ReplicationThread-" + threadName;
updateThread = new ReplicationThread(intervalInMilliseconds, threadName, DoUpdate, HandleUpdateException, updateLock);
updateThread.Start();
// we rely on isAlive to return true in isUpdateThreadAlive, assert to be on the safe side
if (Debugging.AssertsEnabled)
{
Debugging.Assert(updateThread.IsAlive, "updateThread started but not alive?");
}
}
finally
{
UninterruptableMonitor.Exit(syncLock);
}
}
// NOTE: acceptDocs applies (and is checked) only in the child document space
public override Scorer GetScorer(AtomicReaderContext readerContext, IBits acceptDocs)
{
Scorer parentScorer = _parentWeight.GetScorer(readerContext, null);
if (parentScorer is null)
{
// No matches
return(null);
}
// NOTE: we cannot pass acceptDocs here because this
// will (most likely, justifiably) cause the filter to
// not return a FixedBitSet but rather a
// BitsFilteredDocIdSet. Instead, we filter by
// acceptDocs when we score:
DocIdSet parents = _parentsFilter.GetDocIdSet(readerContext, null);
if (parents is null)
{
// No matches
return(null);
}
if (!(parents is FixedBitSet))
{
throw IllegalStateException.Create("parentFilter must return FixedBitSet; got " + parents);
}
return(new ToChildBlockJoinScorer(this, parentScorer, (FixedBitSet)parents, _doScores, acceptDocs));
}
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
IDictionary <string, FunctionValues> valuesCache = (IDictionary <string, FunctionValues>)context["valuesCache"];
if (valuesCache == null)
{
valuesCache = new Dictionary <string, FunctionValues>();
context = new Hashtable(context)
{
["valuesCache"] = valuesCache
};
}
FunctionValues[] externalValues = new FunctionValues[expression.Variables.Length];
for (int i = 0; i < variables.Length; ++i)
{
string externalName = expression.Variables[i];
if (!valuesCache.TryGetValue(externalName, out FunctionValues values))
{
values = variables[i].GetValues(context, readerContext);
if (values == null)
{
// LUCENENET specific: Changed from RuntimeException to InvalidOperationException to match .NET conventions
#pragma warning disable IDE0016 // Use 'throw' expression
throw IllegalStateException.Create($"Internal error. External ({externalName}) does not exist.");
#pragma warning restore IDE0016 // Use 'throw' expression
}
valuesCache[externalName] = values;
}
externalValues[i] = values;
}
return(new ExpressionFunctionValues(this, expression, externalValues));
}
protected abstract void Dispose(bool disposing); // LUCENENET: Refactored from DoClose()
/// <summary>
/// Expert: decreases the refCount of this TaxonomyReader instance. If the
/// refCount drops to 0 this taxonomy reader is closed.
/// </summary>
public void DecRef()
{
EnsureOpen();
int rc = refCount.DecrementAndGet();
if (rc == 0)
{
bool success = false;
try
{
Dispose(true); // LUCENENET specific - changed from DoClose() to Dispose(bool)
closed = true;
success = true;
}
finally
{
if (!success)
{
// Put reference back on failure
refCount.IncrementAndGet();
}
}
}
else if (rc < 0)
{
throw IllegalStateException.Create("too many decRef calls: refCount is " + rc + " after decrement");
}
}
private void CheckNotFinished()
{
if (m_finished)
{
throw IllegalStateException.Create("Already finished");
}
}
private void CheckIfFrozen()
{
if (frozen)
{
throw IllegalStateException.Create("this FieldType is already frozen and cannot be changed");
}
}
/// <summary>
/// Releases resources used by the <see cref="SearcherLifetimeManager"/> and
/// if overridden in a derived class, optionally releases unmanaged resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
/// <c>false</c> to release only unmanaged resources.</param>
// LUCENENET specific - implemented proper dispose pattern
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
lock (this)
{
_closed = true;
IList <SearcherTracker> toClose = new List <SearcherTracker>(_searchers.Values.Select(item => item.Value));
// Remove up front in case exc below, so we don't
// over-decRef on double-close:
foreach (var tracker in toClose)
{
_searchers.TryRemove(tracker.Version, out Lazy <SearcherTracker> _);
}
IOUtils.Dispose(toClose);
// Make some effort to catch mis-use:
if (_searchers.Count != 0)
{
throw IllegalStateException.Create("another thread called record while this SearcherLifetimeManager instance was being disposed; not all searchers were disposed");
}
}
}
}
/// <summary/>
/// <exception cref="InvalidOperationException"></exception>
public virtual void DecRef()
{
if (refCount <= 0)
{
throw IllegalStateException.Create("this revision is already released");
}
var rc = refCount.DecrementAndGet();
if (rc == 0)
{
bool success = false;
try
{
Revision.Release();
success = true;
}
finally
{
if (!success)
{
// Put reference back on failure
refCount.IncrementAndGet();
}
}
}
else if (rc < 0)
{
throw IllegalStateException.Create(string.Format("too many decRef calls: refCount is {0} after decrement", rc));
}
}
private void Add(int doc, long?value) // LUCENENET specific: Marked private instead of public and changed the value parameter type
{
// TODO: if the Sorter interface changes to take long indexes, we can remove that limitation
if (size == int.MaxValue)
{
throw IllegalStateException.Create("cannot support more than System.Int32.MaxValue doc/value entries");
}
long?val = value;
if (val == null)
{
val = NumericDocValuesUpdate.MISSING;
}
// grow the structures to have room for more elements
if (docs.Count == size)
{
docs = docs.Grow(size + 1);
values = values.Grow(size + 1);
docsWithField = FixedBitSet.EnsureCapacity(docsWithField, (int)docs.Count);
}
if (val != NumericDocValuesUpdate.MISSING)
{
// only mark the document as having a value in that field if the value wasn't set to null (MISSING)
docsWithField.Set(size);
}
docs.Set(size, doc);
values.Set(size, val.Value);
++size;
}
private void EnsureIndexIsRead()
{
if (index == null)
{
throw IllegalStateException.Create("terms index was not loaded when this reader was created");
}
}
public override void Merge(DocValuesFieldUpdates other)
{
BinaryDocValuesFieldUpdates otherUpdates = (BinaryDocValuesFieldUpdates)other;
int newSize = size + otherUpdates.size;
if (newSize > int.MaxValue)
{
throw IllegalStateException.Create("cannot support more than System.Int32.MaxValue doc/value entries; size=" + size + " other.size=" + otherUpdates.size);
}
docs = docs.Grow(newSize);
offsets = offsets.Grow(newSize);
lengths = lengths.Grow(newSize);
docsWithField = FixedBitSet.EnsureCapacity(docsWithField, (int)docs.Count);
for (int i = 0; i < otherUpdates.size; i++)
{
int doc = (int)otherUpdates.docs.Get(i);
if (otherUpdates.docsWithField.Get(i))
{
docsWithField.Set(size);
}
docs.Set(size, doc);
offsets.Set(size, values.Length + otherUpdates.offsets.Get(i)); // correct relative offset
lengths.Set(size, otherUpdates.lengths.Get(i));
++size;
}
values.Append(otherUpdates.values);
}
/// <summary>
/// USed to get the versioned operation response. It contains version information of the data in the server.
/// </summary>
/// <param name="transport"></param>
/// <param name="param"></param>
/// <returns>Version data on the entry picked</returns>
protected VersionedOperationResponse returnVersionedOperationResponse(Transport transport, HeaderParams param)
{
byte respStatus = readHeaderAndValidate(transport, param);
if (logger.IsTraceEnabled)
{
logger.Trace("Read response status : " + respStatus);
}
VersionedOperationResponse.RspCode code;
if (respStatus == NO_ERROR_STATUS)
{
code = VersionedOperationResponse.RspCode.SUCCESS;
}
else if (respStatus == NOT_PUT_REMOVED_REPLACED_STATUS)
{
code = VersionedOperationResponse.RspCode.MODIFIED_KEY;
}
else if (respStatus == KEY_DOES_NOT_EXIST_STATUS)
{
code = VersionedOperationResponse.RspCode.NO_SUCH_KEY;
}
else
{
IllegalStateException e = new IllegalStateException("Unknown response status: " + respStatus);
logger.Warn(e);
throw e;
}
byte[] prevValue = returnPossiblePrevValue(transport);
return(new VersionedOperationResponse(prevValue, code));
}
/// <summary>
/// Decrements the reference counting of this object. When reference counting
/// hits 0, calls <see cref="Release()"/>.
/// </summary>
public void DecRef()
{
int rc = refCount.DecrementAndGet();
if (rc == 0)
{
bool success = false;
try
{
Release();
success = true;
}
finally
{
if (!success)
{
// Put reference back on failure
refCount.IncrementAndGet();
}
}
}
else if (rc < 0)
{
throw IllegalStateException.Create("too many DecRef() calls: refCount is " + rc + " after decrement");
}
}
/// <summary>
/// This method is called every time a child is processed.
/// </summary>
/// <param name="queryTree">the query node child to be processed</param>
/// <exception cref="QueryNodeException">if something goes wrong during the query node processing</exception>
protected virtual void ProcessChildren(IQueryNode queryTree)
{
IList <IQueryNode> children = queryTree.GetChildren();
ChildrenList newChildren;
if (children != null && children.Count > 0)
{
newChildren = AllocateChildrenList();
try
{
foreach (IQueryNode child in children)
{
var child2 = ProcessIteration(child);
if (child2 == null)
{
// LUCENENET: Changed from NullPointerException to InvalidOperationException (which isn't caught anywhere outside of tests)
throw IllegalStateException.Create($"{this.GetType().Name}.PostProcessNode() must not return 'null'.");
}
newChildren.Add(child2);
}
IList <IQueryNode> orderedChildrenList = SetChildrenOrder(newChildren);
queryTree.Set(orderedChildrenList);
}
finally
{
newChildren.beingUsed = false;
}
}
}
/// <summary>
/// Release a snapshot by generation. </summary>
protected internal virtual void ReleaseGen(long gen)
{
if (!initCalled)
{
throw IllegalStateException.Create("this instance is not being used by IndexWriter; be sure to use the instance returned from writer.Config.IndexDeletionPolicy");
}
int?refCount = m_refCounts[gen];
if (refCount == null)
{
throw new ArgumentException("commit gen=" + gen + " is not currently snapshotted");
}
int refCountInt = (int)refCount;
if (Debugging.AssertsEnabled)
{
Debugging.Assert(refCountInt > 0);
}
refCountInt--;
if (refCountInt == 0)
{
m_refCounts.Remove(gen);
m_indexCommits.Remove(gen);
}
else
{
m_refCounts[gen] = refCountInt;
}
}
protected override SearcherAndTaxonomy RefreshIfNeeded(SearcherAndTaxonomy @ref)
{
// Must re-open searcher first, otherwise we may get a
// new reader that references ords not yet known to the
// taxonomy reader:
IndexReader r = @ref.Searcher.IndexReader;
IndexReader newReader = DirectoryReader.OpenIfChanged((DirectoryReader)r);
if (newReader == null)
{
return(null);
}
else
{
var tr = TaxonomyReader.OpenIfChanged(@ref.TaxonomyReader);
if (tr == null)
{
@ref.TaxonomyReader.IncRef();
tr = @ref.TaxonomyReader;
}
else if (taxoWriter != null && taxoWriter.TaxonomyEpoch != taxoEpoch)
{
IOUtils.Dispose(newReader, tr);
throw IllegalStateException.Create("DirectoryTaxonomyWriter.ReplaceTaxonomy() was called, which is not allowed when using SearcherTaxonomyManager");
}
return(new SearcherAndTaxonomy(SearcherManager.GetSearcher(searcherFactory, newReader), tr));
}
}
public override bool IncrementToken()
{
if (str == null)
{
throw IllegalStateException.Create("Consumer did not call Reset().");
}
ClearAttributes();
// cache loop instance vars (performance)
string s = str;
int len = s.Length;
int i = pos;
bool letter = isLetter;
int start = 0;
string text;
do
{
// find beginning of token
text = null;
while (i < len && !IsTokenChar(s[i], letter))
{
i++;
}
if (i < len) // found beginning; now find end of token
{
start = i;
while (i < len && IsTokenChar(s[i], letter))
{
i++;
}
text = s.Substring(start, i - start);
if (toLowerCase)
{
text = text.ToLower(); // LUCENENET: Since this class is obsolete, we aren't going to bother with passing culture in the constructor.
}
// if (toLowerCase) {
//// use next line once JDK 1.5 String.toLowerCase() performance regression is fixed
//// see http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6265809
// text = s.substring(start, i).toLowerCase();
//// char[] chars = new char[i-start];
//// for (int j=start; j < i; j++) chars[j-start] = Character.toLowerCase(s.charAt(j));
//// text = new String(chars);
// } else {
// text = s.substring(start, i);
// }
}
} while (text != null && IsStopWord(text));
pos = i;
if (text == null)
{
return(false);
}
termAtt.SetEmpty().Append(text);
offsetAtt.SetOffset(CorrectOffset(start), CorrectOffset(i));
return(true);
}
public override int NextPosition()
{
if (doc != 0)
{
throw IllegalStateException.Create();
}
else if (i >= termFreq - 1)
{
throw IllegalStateException.Create("Read past last position");
}
++i;
if (payloadIndex != null)
{
payload.Offset = basePayloadOffset + payloadIndex[positionIndex + i];
payload.Length = payloadIndex[positionIndex + i + 1] - payloadIndex[positionIndex + i];
}
if (positions == null)
{
return(-1);
}
else
{
return(positions[positionIndex + i]);
}
}
public override Spans GetSpans(AtomicReaderContext context, IBits acceptDocs, IDictionary <Term, TermContext> termContexts)
{
TermState state;
if (!termContexts.TryGetValue(m_term, out TermContext termContext) || termContext == null)
{
// this happens with span-not query, as it doesn't include the NOT side in extractTerms()
// so we seek to the term now in this segment..., this sucks because its ugly mostly!
Fields fields = context.AtomicReader.Fields;
if (fields != null)
{
Terms terms = fields.GetTerms(m_term.Field);
if (terms != null)
{
TermsEnum termsEnum = terms.GetEnumerator();
if (termsEnum.SeekExact(m_term.Bytes))
{
state = termsEnum.GetTermState();
}
else
{
state = null;
}
}
else
{
state = null;
}
}
else
{
state = null;
}
}
else
{
state = termContext.Get(context.Ord);
}
if (state == null) // term is not present in that reader
{
return(TermSpans.EMPTY_TERM_SPANS);
}
TermsEnum termsEnum_ = context.AtomicReader.GetTerms(m_term.Field).GetEnumerator();
termsEnum_.SeekExact(m_term.Bytes, state);
DocsAndPositionsEnum postings = termsEnum_.DocsAndPositions(acceptDocs, null, DocsAndPositionsFlags.PAYLOADS);
if (postings != null)
{
return(new TermSpans(postings, m_term));
}
else
{
// term does exist, but has no positions
throw IllegalStateException.Create("field \"" + m_term.Field + "\" was indexed without position data; cannot run SpanTermQuery (term=" + m_term.Text + ")");
}
}
public override int NextPosition()
{
//if (Debugging.AssertsEnabled) Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
// LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
// caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
// part that is checking for an error after reading to the end of the enumerator.
// In .NET it is more natural to throw an InvalidOperationException in this case, since we would potentially get an
// IndexOutOfRangeException if we didn't, which doesn't really provide good feedback as to what the cause is.
// This matches the behavior of Lucene 8.x. See #267.
if (((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length) == false)
{
throw IllegalStateException.Create("Read past last position");
}
if (positions != null)
{
return(positions[nextPos++]);
}
else
{
nextPos++;
return(-1);
}
}
public UnionDocsAndPositionsEnum(IBits liveDocs, AtomicReaderContext context, Term[] terms, IDictionary <Term, TermContext> termContexts, TermsEnum termsEnum)
{
ICollection <DocsAndPositionsEnum> docsEnums = new LinkedList <DocsAndPositionsEnum>();
for (int i = 0; i < terms.Length; i++)
{
Term term = terms[i];
TermState termState = termContexts[term].Get(context.Ord);
if (termState is null)
{
// Term doesn't exist in reader
continue;
}
termsEnum.SeekExact(term.Bytes, termState);
DocsAndPositionsEnum postings = termsEnum.DocsAndPositions(liveDocs, null, DocsAndPositionsFlags.NONE);
if (postings is null)
{
// term does exist, but has no positions
throw IllegalStateException.Create("field \"" + term.Field + "\" was indexed without position data; cannot run PhraseQuery (term=" + term.Text + ")");
}
_cost += postings.GetCost();
docsEnums.Add(postings);
}
_queue = new DocsQueue(docsEnums);
_posList = new Int32Queue();
}
/// <summary>
/// Constructor with the given index directory and callback to notify when the indexes were updated.
/// </summary>
/// <exception cref="IOException"></exception>
public IndexAndTaxonomyReplicationHandler(Directory indexDirectory, Directory taxonomyDirectory, Func <bool?> callback)
{
this.indexDirectory = indexDirectory;
this.taxonomyDirectory = taxonomyDirectory;
this.callback = callback;
currentVersion = null;
currentRevisionFiles = null;
bool indexExists = DirectoryReader.IndexExists(indexDirectory);
bool taxonomyExists = DirectoryReader.IndexExists(taxonomyDirectory);
if (indexExists != taxonomyExists)
{
throw IllegalStateException.Create(string.Format("search and taxonomy indexes must either both exist or not: index={0} taxo={1}", indexExists, taxonomyExists));
}
if (indexExists)
{
IndexCommit indexCommit = IndexReplicationHandler.GetLastCommit(indexDirectory);
IndexCommit taxonomyCommit = IndexReplicationHandler.GetLastCommit(taxonomyDirectory);
currentRevisionFiles = IndexAndTaxonomyRevision.RevisionFiles(indexCommit, taxonomyCommit);
currentVersion = IndexAndTaxonomyRevision.RevisionVersion(indexCommit, taxonomyCommit);
WriteToInfoStream(
string.Format("constructor(): currentVersion={0} currentRevisionFiles={1}", currentVersion, currentRevisionFiles),
string.Format("constructor(): indexCommit={0} taxoCommit={1}", indexCommit, taxonomyCommit));
}
}
/// <summary>
/// Add data from another stat, for aggregation.
/// </summary>
/// <param name="stat2">The added stat data.</param>
public virtual void Add(TaskStats stat2)
{
numRuns += stat2.NumRuns;
elapsed += stat2.Elapsed;
maxTotMem += stat2.MaxTotMem;
maxUsedMem += stat2.MaxUsedMem;
count += stat2.Count;
if (round != stat2.round)
{
round = -1; // no meaning if aggregating tasks of different round.
}
if (countsByTime != null && stat2.countsByTime != null)
{
if (countsByTimeStepMSec != stat2.countsByTimeStepMSec)
{
throw IllegalStateException.Create("different by-time msec step");
}
if (countsByTime.Length != stat2.countsByTime.Length)
{
throw IllegalStateException.Create("different by-time msec count");
}
for (int i = 0; i < stat2.countsByTime.Length; i++)
{
countsByTime[i] += stat2.countsByTime[i];
}
}
}
public override void Merge(DocValuesFieldUpdates other)
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(other is NumericDocValuesFieldUpdates);
}
NumericDocValuesFieldUpdates otherUpdates = (NumericDocValuesFieldUpdates)other;
if (size + otherUpdates.size > int.MaxValue)
{
throw IllegalStateException.Create("cannot support more than System.Int32.MaxValue doc/value entries; size=" + size + " other.size=" + otherUpdates.size);
}
docs = docs.Grow(size + otherUpdates.size);
values = values.Grow(size + otherUpdates.size);
docsWithField = FixedBitSet.EnsureCapacity(docsWithField, (int)docs.Count);
for (int i = 0; i < otherUpdates.size; i++)
{
int doc = (int)otherUpdates.docs.Get(i);
if (otherUpdates.docsWithField.Get(i))
{
docsWithField.Set(size);
}
docs.Set(size, doc);
values.Set(size, otherUpdates.values.Get(i));
++size;
}
}
public override void Run()
{
foreach (int q in queries)
{
Query query = new TermQuery(new Term("fld", "" + q));
try
{
TopDocs topDocs = searcher.Search(query, 1);
if (topDocs.TotalHits != 1)
{
Console.WriteLine(query);
throw IllegalStateException.Create("Expected 1 hit, got " + topDocs.TotalHits);
}
Document sdoc = rd.Document(topDocs.ScoreDocs[0].Doc);
if (sdoc is null || sdoc.Get("fld") is null)
{
throw IllegalStateException.Create("Could not find document " + q);
}
if (!Convert.ToString(q, CultureInfo.InvariantCulture).Equals(sdoc.Get("fld"), StringComparison.Ordinal))
{
throw IllegalStateException.Create("Expected " + q + ", but got " + sdoc.Get("fld"));
}
}
catch (Exception e) when(e.IsException())
{
ex.CompareAndSet(null, e);
}
}
}
/// <summary>
/// Called initially, and whenever <see cref="Visit(Lucene.Net.Spatial.Prefix.Tree.Cell)"/>
/// returns true.
/// </summary>
/// <exception cref="IOException"></exception>
private void AddIntersectingChildren()
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(thisTerm != null);
}
Cell cell = curVNode.cell;
if (cell.Level >= m_outerInstance.m_detailLevel)
{
throw IllegalStateException.Create("Spatial logic error");
}
//Check for adjacent leaf (happens for indexed non-point shapes)
if (m_hasIndexedLeaves && cell.Level != 0)
{
//If the next indexed term just adds a leaf marker ('+') to cell,
// then add all of those docs
if (Debugging.AssertsEnabled)
{
Debugging.Assert(StringHelper.StartsWith(thisTerm, curVNodeTerm)); //TODO refactor to use method on curVNode.cell
}
scanCell = m_outerInstance.m_grid.GetCell(thisTerm.Bytes, thisTerm.Offset, thisTerm.Length, scanCell);
if (scanCell.Level == cell.Level && scanCell.IsLeaf)
{
VisitLeaf(scanCell);
//advance
if (!m_termsEnum.MoveNext())
{
return;// all done
}
thisTerm = m_termsEnum.Term;
}
}
//Decide whether to continue to divide & conquer, or whether it's time to
// scan through terms beneath this cell.
// Scanning is a performance optimization trade-off.
//TODO use termsEnum.docFreq() as heuristic
bool scan = cell.Level >= ((AbstractVisitingPrefixTreeFilter)m_outerInstance).m_prefixGridScanLevel;//simple heuristic
if (!scan)
{
//Divide & conquer (ultimately termsEnum.seek())
IEnumerator <Cell> subCellsIter = FindSubCellsToVisit(cell);
if (!subCellsIter.MoveNext())
{
return;//not expected
}
curVNode.children = new VNodeCellIterator(subCellsIter, new VNode(curVNode));
}
else
{
//Scan (loop of termsEnum.next())
Scan(m_outerInstance.m_detailLevel);
}
}
