/** Same as {@link #copy(Reader, int, Mutable, int, int, int)} but using a pre-allocated buffer. */ static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, long[] buf) { assert buf.length > 0; int remaining = 0; while (len > 0) { final int read = src.get(srcPos, buf, remaining, Math.min(len, buf.length - remaining)); assert read > 0; srcPos += read; len -= read; remaining += read; final int written = dest.set(destPos, buf, 0, remaining); assert written > 0; destPos += written; if (written < remaining) { System.arraycopy(buf, written, buf, 0, remaining - written); } remaining -= written; } while (remaining > 0) { final int written = dest.set(destPos, buf, 0, remaining); destPos += written; remaining -= written; System.arraycopy(buf, written, buf, 0, remaining); } }
/** * Bulk get: read at least one and at most <code>len</code> longs starting * from <code>index</code> into <code>arr[off:off+len]</code> and return * the actual number of values that have been read. */ public int get(int index, long[] arr, int off, int len) { assert len > 0 : "len must be > 0 (got " + len + ")"; assert index >= 0 && index < size(); assert off + len <= arr.length; final int gets = Math.min(size() - index, len); for (int i = index, o = off, end = index + gets; i < end; ++i, ++o) { arr[o] = get(i); } return gets; }
/** * Copy <code>src[srcPos:srcPos+len]</code> into * <code>dest[destPos:destPos+len]</code> using at most <code>mem</code> * bytes. */ public static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, int mem) { assert srcPos + len <= src.size(); assert destPos + len <= dest.size(); final int capacity = mem >>> 3; if (capacity == 0) { for (int i = 0; i < len; ++i) { dest.set(destPos++, src.get(srcPos++)); } } else if (len > 0) { // use bulk operations final long[] buf = new long[Math.min(capacity, len)]; copy(src, srcPos, dest, destPos, len, buf); } }
private long relativeStartPointer(int block, int relativeChunk) { final long expected = avgChunkSizes[block] * relativeChunk; final long delta = zigZagDecode(startPointersDeltas[block].get(relativeChunk)); return expected + delta; }
@Override public long get(long index) { assert index >= 0 && index < valueCount; final int block = (int) (index >>> blockShift); final int idx = (int) (index & blockMask); return (minValues == null ? 0 : minValues[block]) + subReaders[block].get(idx); }
@Override public long get(long index) { assert index >= 0 && index < valueCount; final int block = (int) (index >>> blockShift); final int idx = (int) (index & blockMask); return expected(minValues[block], averages[block], idx) + subReaders[block].get(idx); }
@Override public long get(int docID) { return minDelta + deltaReader.get(docID); } };
private int relativeDocBase(int block, int relativeChunk) { final int expected = avgChunkDocs[block] * relativeChunk; final long delta = zigZagDecode(docBasesDeltas[block].get(relativeChunk)); return expected + (int) delta; }
@Override public boolean advanceExact(int docID) throws IOException { currentDoc = docID; currentOrd = (int) (reader.get(docID) - 1); return currentOrd != -1; }
PackedInts.Mutable f = PackedInts.getMutable(totalFields, FLAGS_BITS, PackedInts.COMPACT); for (int i = 0; i < totalFields; ++i) { final int fieldNumOff = (int) allFieldNumOffs.get(i); assert fieldNumOff >= 0 && fieldNumOff < fieldNums.length; final int fgs = (int) fieldFlags.get(fieldNumOff); f.set(i, fgs); fieldNumOffs[i] = (int) allFieldNumOffs.get(skip + i); int sum = 0; for (int i = 0; i < totalFields; ++i) { sum += numTerms.get(i); toSkip += numTerms.get(i); final int termCount = (int) numTerms.get(skip + i); final int[] fieldPrefixLengths = new int[termCount]; prefixLengths[i] = fieldPrefixLengths; for (int j = 0; j < numTerms.get(i); ++j) { docOff += reader.next(); final int termCount = (int) numTerms.get(skip + i); final int[] fieldSuffixLengths = new int[termCount]; suffixLengths[i] = fieldSuffixLengths; for (int j = 0; j < numTerms.get(i); ++j) { totalLen += reader.next();
int termIndex = 0; for (int i = 0; i < skip; ++i) { final int f = (int) flags.get(i); final int termCount = (int) numTerms.get(i); if ((f & flag) != 0) { for (int j = 0; j < termCount; ++j) { final int f = (int) flags.get(skip + i); final int termCount = (int) numTerms.get(skip + i); if ((f & flag) != 0) { final int totalFreq = positionIndex[i][termCount];
private int[][] positionIndex(int skip, int numFields, PackedInts.Reader numTerms, int[] termFreqs) { final int[][] positionIndex = new int[numFields][]; int termIndex = 0; for (int i = 0; i < skip; ++i) { final int termCount = (int) numTerms.get(i); termIndex += termCount; } for (int i = 0; i < numFields; ++i) { final int termCount = (int) numTerms.get(skip + i); positionIndex[i] = new int[termCount + 1]; for (int j = 0; j < termCount; ++j) { final int freq = termFreqs[termIndex+j]; positionIndex[i][j + 1] = positionIndex[i][j] + freq; } termIndex += termCount; } return positionIndex; }
long get(int block, int element) { return values[block].get(element); }
@Override long get(int block, int element) { return expected(mins[block], averages[block], element) + values[block].get(element); }
@Override long get(int block, int element) { return mins[block] + values[block].get(element); }
private long relativeStartPointer(int block, int relativeChunk) { final long expected = avgChunkSizes[block] * relativeChunk; final long delta = zigZagDecode(startPointersDeltas[block].get(relativeChunk)); return expected + delta; }
@Override public long get(long index) { assert index >= 0 && index < valueCount; final int block = (int) (index >>> blockShift); final int idx = (int) (index & blockMask); return (minValues == null ? 0 : minValues[block]) + subReaders[block].get(idx); }
int decodeBlock(int block, long[] dest) { final PackedInts.Reader vals = values[block]; final int size = vals.size(); for (int k = 0; k < size; ) { k += vals.get(k, dest, k, size - k); } return size; }
@Override public long get(long index) { assert index >= 0 && index < valueCount; final int block = (int) (index >>> blockShift); final int idx = (int) (index & blockMask); return expected(minValues[block], averages[block], idx) + subReaders[block].get(idx); }
private int relativeDocBase(int block, int relativeChunk) { final int expected = avgChunkDocs[block] * relativeChunk; final long delta = zigZagDecode(docBasesDeltas[block].get(relativeChunk)); return expected + (int) delta; }