/** Seeks to smallest term that's >= target. */ public InputOutput<T> seekCeil(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekCeil(); return setResult(); }
public InputOutput<T> next() throws IOException { //System.out.println(" enum.next"); doNext(); return setResult(); }
/** Seeks to biggest term that's <= target. */ public InputOutput<T> seekFloor(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekFloor(); return setResult(); }
/** Seeks to exactly this term, returning null if the term * doesn't exist. This is faster than using {@link * #seekFloor} or {@link #seekCeil} because it * short-circuits as soon the match is not found. */ public InputOutput<T> seekExact(BytesRef target) throws IOException { this.target = target; targetLength = target.length; if (super.doSeekExact()) { assert upto == 1+target.length; return setResult(); } else { return null; } }
public InputOutput<T> next() throws IOException { //System.out.println(" enum.next"); doNext(); return setResult(); }
/** Seeks to biggest term that's <= target. */ public InputOutput<T> seekFloor(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekFloor(); return setResult(); }
public InputOutput<T> next() throws IOException { //System.out.println(" enum.next"); doNext(); return setResult(); }
public InputOutput<T> next() throws IOException { //System.out.println(" enum.next"); doNext(); return setResult(); }
/** Seeks to smallest term that's >= target. */ public InputOutput<T> seekCeil(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekCeil(); return setResult(); }
/** Seeks to biggest term that's <= target. */ public InputOutput<T> seekFloor(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekFloor(); return setResult(); }
/** Seeks to smallest term that's >= target. */ public InputOutput<T> seekCeil(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekCeil(); return setResult(); }
/** Seeks to biggest term that's <= target. */ public InputOutput<T> seekFloor(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekFloor(); return setResult(); }
/** Seeks to smallest term that's >= target. */ public InputOutput<T> seekCeil(BytesRef target) throws IOException { this.target = target; targetLength = target.length; super.doSeekCeil(); return setResult(); }
/** Seeks to exactly this term, returning null if the term * doesn't exist. This is faster than using {@link * #seekFloor} or {@link #seekCeil} because it * short-circuits as soon the match is not found. */ public InputOutput<T> seekExact(BytesRef target) throws IOException { this.target = target; targetLength = target.length; if (super.doSeekExact()) { assert upto == 1+target.length; return setResult(); } else { return null; } }
/** Seeks to exactly this term, returning null if the term * doesn't exist. This is faster than using {@link * #seekFloor} or {@link #seekCeil} because it * short-circuits as soon the match is not found. */ public InputOutput<T> seekExact(BytesRef target) throws IOException { this.target = target; targetLength = target.length; if (super.doSeekExact()) { assert upto == 1+target.length; return setResult(); } else { return null; } }
/** Seeks to exactly this term, returning null if the term * doesn't exist. This is faster than using {@link * #seekFloor} or {@link #seekCeil} because it * short-circuits as soon the match is not found. */ public InputOutput<T> seekExact(BytesRef target) throws IOException { this.target = target; targetLength = target.length; if (super.doSeekExact()) { assert upto == 1+target.length; return setResult(); } else { return null; } }