@Override public Object toObject() { assert exists || 0 == value.length(); return exists ? value.get().utf8ToString() : null; }
@Override public int hashCode() { assert exists || 0 == value.length(); return value.get().hashCode(); } }
/** Pushes the new term to the top of the stack, and writes new blocks. */ private void pushTerm(BytesRef text) throws IOException { int limit = Math.min(lastTerm.length(), text.length); // Find common prefix between last term and current term: int pos = 0; while (pos < limit && lastTerm.byteAt(pos) == text.bytes[text.offset+pos]) { pos++; } // if (DEBUG) System.out.println(" shared=" + pos + " lastTerm.length=" + lastTerm.length); // Close the "abandoned" suffix now: for(int i=lastTerm.length()-1;i>=pos;i--) { // How many items on top of the stack share the current suffix // we are closing: int prefixTopSize = pending.size() - prefixStarts[i]; if (prefixTopSize >= minItemsInBlock) { // if (DEBUG) System.out.println("pushTerm i=" + i + " prefixTopSize=" + prefixTopSize + " minItemsInBlock=" + minItemsInBlock); writeBlocks(i+1, prefixTopSize); prefixStarts[i] -= prefixTopSize-1; } } if (prefixStarts.length < text.length) { prefixStarts = ArrayUtil.grow(prefixStarts, text.length); } // Init new tail: for(int i=pos;i<text.length;i++) { prefixStarts[i] = pending.size(); } lastTerm.copyBytes(text); }
@Override public boolean equalsSameType(Object other) { assert exists || 0 == value.length(); MutableValueStr b = (MutableValueStr)other; return value.get().equals(b.value.get()) && exists == b.exists; }
@Override public int compareSameType(Object other) { assert exists || 0 == value.length(); MutableValueStr b = (MutableValueStr)other; int c = value.get().compareTo(b.value.get()); if (c != 0) return c; if (exists == b.exists) return 0; return exists ? 1 : -1; }
@Override synchronized public void add(int doc, BytesRef value) { int index = add(doc); offsets.set(index, values.length()); lengths.set(index, value.length); values.append(value); }
@Override public int nextPosition() throws IOException { assert posLeft > 0; posLeft--; int code = posReader.readVInt(); pos += code >>> 1; if ((code & 1) != 0) { hasPayload = true; // has a payload payload.setLength(posReader.readVInt()); payload.grow(payload.length()); posReader.readBytes(payload.bytes(), 0, payload.length()); } else { hasPayload = false; } if (readOffsets) { startOffset += posReader.readVInt(); endOffset = startOffset + posReader.readVInt(); } return pos; }
public void nextLeaf() { //if (DEBUG) System.out.println(" frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount); assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp; nextEnt++; suffix = suffixesReader.readVInt(); startBytePos = suffixesReader.getPosition(); ste.term.setLength(prefix + suffix); ste.term.grow(ste.term.length()); suffixesReader.readBytes(ste.term.bytes(), prefix, suffix); ste.termExists = true; }
@Override protected BytesRef nextSeekTerm(final BytesRef term) throws IOException { //System.out.println("ATE.nextSeekTerm term=" + term); if (term == null) { assert seekBytesRef.length() == 0; // return the empty term, as it's valid if (runAutomaton.isAccept(0)) { return seekBytesRef.get(); } } else { seekBytesRef.copyBytes(term); } // seek to the next possible string; if (nextString()) { return seekBytesRef.get(); // reposition } else { return null; // no more possible strings can match } }
if (position < seekBytesRef.length()) { c = seekBytesRef.byteAt(position) & 0xff; int nextChar = Math.max(c, transition.min); seekBytesRef.grow(seekBytesRef.length() + 1); seekBytesRef.append((byte) nextChar); state = transition.dest; seekBytesRef.grow(seekBytesRef.length() + 1); seekBytesRef.append((byte) transition.min); setLinear(seekBytesRef.length()-1);
/** * Returns the <i>n'th</i> element of this {@link BytesRefArray} * @param spare a spare {@link BytesRef} instance * @param index the elements index to retrieve * @return the <i>n'th</i> element of this {@link BytesRefArray} */ public BytesRef get(BytesRefBuilder spare, int index) { FutureObjects.checkIndex(index, lastElement); int offset = offsets[index]; int length = index == lastElement - 1 ? currentOffset - offset : offsets[index + 1] - offset; spare.grow(length); spare.setLength(length); pool.readBytes(offset, spare.bytes(), 0, spare.length()); return spare.get(); }
assert validIndexPrefix <= term.length(); final int targetLimit2 = Math.min(target.length, term.length()); while (targetUpto < targetLimit2) { cmp = (term.byteAt(targetUpto)&0xFF) - (target.bytes[target.offset + targetUpto]&0xFF); cmp = term.length() - target.length; } else { assert term.length() == target.length; if (termExists) {
startBytePos = suffixesReader.getPosition(); ste.term.setLength(prefix + suffix); ste.term.grow(ste.term.length()); suffixesReader.readBytes(ste.term.bytes(), prefix, suffix); if ((code & 1) == 0) {
currentFrame = pushFrame(null, currentFrame.lastSubFP, term.length());
ste.currentFrame.loadBlock(); while (ste.currentFrame.next()) { ste.currentFrame = ste.pushFrame(null, ste.currentFrame.lastSubFP, ste.term.length()); ste.currentFrame.loadBlock();
if (currentFrame.next()) { currentFrame = pushFrame(null, currentFrame.lastSubFP, term.length()); currentFrame.fpOrig = currentFrame.fp;