public void Init(ByteBlockPool pool, int startIndex, int endIndex)
{
Debug.Assert(endIndex - startIndex >= 0);
Debug.Assert(startIndex >= 0);
Debug.Assert(endIndex >= 0);
this.Pool = pool;
this.EndIndex = endIndex;
Level = 0;
BufferUpto = startIndex / ByteBlockPool.BYTE_BLOCK_SIZE;
BufferOffset = BufferUpto * ByteBlockPool.BYTE_BLOCK_SIZE;
Buffer = pool.Buffers[BufferUpto];
Upto = startIndex & ByteBlockPool.BYTE_BLOCK_MASK;
int firstSize = ByteBlockPool.LEVEL_SIZE_ARRAY[0];
if (startIndex + firstSize >= endIndex)
{
// There is only this one slice to read
Limit = endIndex & ByteBlockPool.BYTE_BLOCK_MASK;
}
else
{
Limit = Upto + firstSize - 4;
}
}
public TermsHash(DocumentsWriterPerThread docWriter, TermsHashConsumer consumer, bool trackAllocations, TermsHash nextTermsHash)
{
this.DocState = docWriter.docState;
this.Consumer = consumer;
this.TrackAllocations = trackAllocations;
this.NextTermsHash = nextTermsHash;
this.BytesUsed = trackAllocations ? docWriter.bytesUsed : Counter.NewCounter();
IntPool = new IntBlockPool(docWriter.intBlockAllocator);
BytePool = new ByteBlockPool(docWriter.ByteBlockAllocator);
if (nextTermsHash != null)
{
// We are primary
Primary = true;
TermBytePool = BytePool;
nextTermsHash.TermBytePool = BytePool;
}
else
{
Primary = false;
}
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHash termsHash, TermsHash nextTermsHash, FieldInfo fieldInfo)
{
IntPool = termsHash.IntPool;
BytePool = termsHash.BytePool;
TermBytePool = termsHash.TermBytePool;
DocState = termsHash.DocState;
this.TermsHash = termsHash;
BytesUsed = termsHash.BytesUsed;
FieldState = docInverterPerField.FieldState;
this.Consumer = termsHash.Consumer.AddField(this, fieldInfo);
PostingsBytesStartArray byteStarts = new PostingsBytesStartArray(this, BytesUsed);
BytesHash = new BytesRefHash(TermBytePool, HASH_INIT_SIZE, byteStarts);
StreamCount = Consumer.StreamCount;
NumPostingInt = 2 * StreamCount;
this.FieldInfo = fieldInfo;
if (nextTermsHash != null)
{
NextPerField = (TermsHashPerField)nextTermsHash.AddField(docInverterPerField, fieldInfo);
}
else
{
NextPerField = null;
}
}
public ByteSliceWriter(ByteBlockPool pool)
{
this.Pool = pool;
}
public virtual void TestBasic()
{
ByteBlockPool pool = new ByteBlockPool(new RecyclingByteBlockAllocator(ByteBlockPool.BYTE_BLOCK_SIZE, Random().Next(100)));
int NUM_STREAM = AtLeast(100);
ByteSliceWriter writer = new ByteSliceWriter(pool);
int[] starts = new int[NUM_STREAM];
int[] uptos = new int[NUM_STREAM];
int[] counters = new int[NUM_STREAM];
ByteSliceReader reader = new ByteSliceReader();
for (int ti = 0; ti < 100; ti++)
{
for (int stream = 0; stream < NUM_STREAM; stream++)
{
starts[stream] = -1;
counters[stream] = 0;
}
int num = AtLeast(3000);
for (int iter = 0; iter < num; iter++)
{
int stream;
if (Random().NextBoolean())
{
stream = Random().Next(3);
}
else
{
stream = Random().Next(NUM_STREAM);
}
if (VERBOSE)
{
Console.WriteLine("write stream=" + stream);
}
if (starts[stream] == -1)
{
int spot = pool.NewSlice(ByteBlockPool.FIRST_LEVEL_SIZE);
starts[stream] = uptos[stream] = spot + pool.ByteOffset;
if (VERBOSE)
{
Console.WriteLine(" init to " + starts[stream]);
}
}
writer.Init(uptos[stream]);
int numValue;
if (Random().Next(10) == 3)
{
numValue = Random().Next(100);
}
else if (Random().Next(5) == 3)
{
numValue = Random().Next(3);
}
else
{
numValue = Random().Next(20);
}
for (int j = 0; j < numValue; j++)
{
if (VERBOSE)
{
Console.WriteLine(" write " + (counters[stream] + j));
}
// write some large (incl. negative) ints:
writer.WriteVInt(Random().Next());
writer.WriteVInt(counters[stream] + j);
}
counters[stream] += numValue;
uptos[stream] = writer.Address;
if (VERBOSE)
{
Console.WriteLine(" addr now " + uptos[stream]);
}
}
for (int stream = 0; stream < NUM_STREAM; stream++)
{
if (VERBOSE)
{
Console.WriteLine(" stream=" + stream + " count=" + counters[stream]);
}
if (starts[stream] != -1 && starts[stream] != uptos[stream])
{
reader.Init(pool, starts[stream], uptos[stream]);
for (int j = 0; j < counters[stream]; j++)
{
reader.ReadVInt();
Assert.AreEqual(j, reader.ReadVInt());
}
}
}
pool.Reset();
}
}
