@Override synchronized void add(int doc, long value) { int add = add(doc); values.set(add, value); }
private void addNew(long address) throws IOException { long pos = hash(address) & mask; int c = 0; while(true) { if (table.get(pos) == 0) { table.set(pos, address); break; } // quadratic probe pos = (pos + (++c)) & mask; } }
public long add(Builder<T> builder, Builder.UnCompiledNode<T> nodeIn) throws IOException { //System.out.println("hash: add count=" + count + " vs " + table.size() + " mask=" + mask); final long h = hash(nodeIn); long pos = h & mask; int c = 0; while(true) { final long v = table.get(pos); if (v == 0) { // freeze & add final long node = fst.addNode(builder, nodeIn); //System.out.println(" now freeze node=" + node); assert hash(node) == h : "frozenHash=" + hash(node) + " vs h=" + h; count++; table.set(pos, node); // Rehash at 2/3 occupancy: if (count > 2*table.size()/3) { rehash(); } return node; } else if (nodesEqual(nodeIn, v)) { // same node is already here return v; } // quadratic probe pos = (pos + (++c)) & mask; } }
private int firstLevel(int docID, long ordinal) { // 0 or 1 ordinal if (firstOrdinals.get(docID) == 0L) { firstOrdinals.set(docID, ordinal + 1); return 1; } else { final long newSlice = newSlice(1); if (firstNextLevelSlices == null) { firstNextLevelSlices = new PagedGrowableWriter(firstOrdinals.size(), PAGE_SIZE, 3, acceptableOverheadRatio); } firstNextLevelSlices.set(docID, newSlice); final long offset = startOffset(1, newSlice); ordinals[1].set(offset, ordinal + 1); positions.set(docID, position(1, offset)); // current position is on the 1st level and not allocated yet return 2; } }
private int nonFirstLevel(int docID, long ordinal, long position) { int level = level(position); long offset = offset(position, level); assert offset != 0L; if (((offset + 1) & slotsMask(level)) == 0L) { // reached the end of the slice, allocate a new one on the next level final long newSlice = newSlice(level + 1); if (nextLevelSlices[level] == null) { nextLevelSlices[level] = new PagedGrowableWriter(sizes[level], PAGE_SIZE, 1, acceptableOverheadRatio); } nextLevelSlices[level].set(sliceID(level, offset), newSlice); ++level; offset = startOffset(level, newSlice); assert (offset & slotsMask(level)) == 0L; } else { // just go to the next slot ++offset; } ordinals[level].set(offset, ordinal + 1); final long newPosition = position(level, offset); positions.set(docID, newPosition); return numOrdinals(level, offset); }
@Override synchronized void add(int doc, long value) { int add = add(doc); values.set(add, value); }
@Override protected void swap(int i, int j) { long tmpDoc = docs.get(j); docs.set(j, docs.get(i)); docs.set(i, tmpDoc); long tmpOffset = offsets.get(j); offsets.set(j, offsets.get(i)); offsets.set(i, tmpOffset); long tmpLength = lengths.get(j); lengths.set(j, lengths.get(i)); lengths.set(i, tmpLength); }
@Override protected void swap(int i, int j) { long tmpDoc = docs.get(j); docs.set(j, docs.get(i)); docs.set(i, tmpDoc); long tmpOffset = offsets.get(j); offsets.set(j, offsets.get(i)); offsets.set(i, tmpOffset); long tmpLength = lengths.get(j); lengths.set(j, lengths.get(i)); lengths.set(i, tmpLength); }
private void addNew(long address) throws IOException { long pos = hash(address) & mask; int c = 0; while(true) { if (table.get(pos) == 0) { table.set(pos, address); break; } // quadratic probe pos = (pos + (++c)) & mask; } }
private void addNew(long address) throws IOException { long pos = hash(address) & mask; int c = 0; while(true) { if (table.get(pos) == 0) { table.set(pos, address); break; } // quadratic probe pos = (pos + (++c)) & mask; } }
private void addNew(long address) throws IOException { long pos = hash(address) & mask; int c = 0; while(true) { if (table.get(pos) == 0) { table.set(pos, address); break; } // quadratic probe pos = (pos + (++c)) & mask; } }
@Override public void merge(DocValuesFieldUpdates other) { assert other instanceof NumericDocValuesFieldUpdates; NumericDocValuesFieldUpdates otherUpdates = (NumericDocValuesFieldUpdates) other; if (otherUpdates.size > Integer.MAX_VALUE - size) { throw new IllegalStateException( "cannot support more than Integer.MAX_VALUE doc/value entries; size=" + size + " other.size=" + otherUpdates.size); } docs = docs.grow(size + otherUpdates.size); values = values.grow(size + otherUpdates.size); for (int i = 0; i < otherUpdates.size; i++) { int doc = (int) otherUpdates.docs.get(i); docs.set(size, doc); values.set(size, otherUpdates.values.get(i)); ++size; } }