org.apache.lucene.util.fst

## Class IntsRefFSTEnum<T>

- java.lang.Object
- - org.apache.lucene.util.fst.IntsRefFSTEnum<T>

    public final class IntsRefFSTEnum<T>
    extends Object

Enumerates all input (IntsRef) + output pairs in an FST.

WARNING: This API is experimental and might change in incompatible ways in the next release.

### Nested Class Summary

Nested Classes
`static class` `IntsRefFSTEnum.InputOutput<T>` Holds a single input (IntsRef) + output pair.

### Field Summary

Fields
`protected FST.Arc<T>[]` `arcs`
`protected FST<T>` `fst`
`protected FST.BytesReader` `fstReader`
`protected T` `NO_OUTPUT`
`protected T[]` `output`
`protected FST.Arc<T>` `scratchArc`
`protected int` `targetLength`
`protected int` `upto`

### Constructor Summary

Constructors
Constructor and Description
`IntsRefFSTEnum(FST<T> fst)` doFloor controls the behavior of advance: if it's true doFloor is true, advance positions to the biggest term before target.

### Method Summary

Methods
`IntsRefFSTEnum.InputOutput<T>` `current()`
`protected void` `doNext()`
`protected void` `doSeekCeil()` Seeks to smallest term that's >= target.
`protected boolean` `doSeekExact()` Seeks to exactly target term.
`protected void` `doSeekFloor()` Seeks to largest term that's <= target.
`protected int` `getCurrentLabel()`
`protected int` `getTargetLabel()`
`protected void` `grow()`
`IntsRefFSTEnum.InputOutput<T>` `next()`
`protected void` `rewindPrefix()` Rewinds enum state to match the shared prefix between current term and target term
`IntsRefFSTEnum.InputOutput<T>` `seekCeil(IntsRef target)` Seeks to smallest term that's >= target.
`IntsRefFSTEnum.InputOutput<T>` `seekExact(IntsRef target)` Seeks to exactly this term, returning null if the term doesn't exist.
`IntsRefFSTEnum.InputOutput<T>` `seekFloor(IntsRef target)` Seeks to biggest term that's <= target.
`protected void` `setCurrentLabel(int label)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### fst

    protected final FST<T> fst

#### arcs

    protected FST.Arc<T>[] arcs

#### output

    protected T[] output

#### NO_OUTPUT

    protected final T NO_OUTPUT

#### fstReader

    protected final FST.BytesReader fstReader

#### scratchArc

    protected final FST.Arc<T> scratchArc

#### upto

    protected int upto

#### targetLength

    protected int targetLength

### Constructor Detail

#### IntsRefFSTEnum

    public IntsRefFSTEnum(FST<T> fst)

doFloor controls the behavior of advance: if it's true doFloor is true, advance positions to the biggest term before target.

### Method Detail

#### current

    public IntsRefFSTEnum.InputOutput<T> current()

#### next

    public IntsRefFSTEnum.InputOutput<T> next()
                                       throws IOException

Throws:
  `IOException`

#### seekCeil

    public IntsRefFSTEnum.InputOutput<T> seekCeil(IntsRef target)
                                           throws IOException

Seeks to smallest term that's >= target.

Throws:
  `IOException`

#### seekFloor

    public IntsRefFSTEnum.InputOutput<T> seekFloor(IntsRef target)
                                            throws IOException

Seeks to biggest term that's <= target.

Throws:
  `IOException`

#### seekExact

    public IntsRefFSTEnum.InputOutput<T> seekExact(IntsRef target)
                                            throws IOException

Seeks to exactly this term, returning null if the term doesn't exist. This is faster than using `seekFloor(org.apache.lucene.util.IntsRef)` or `seekCeil(org.apache.lucene.util.IntsRef)` because it short-circuits as soon the match is not found.

Throws:
  `IOException`

#### getTargetLabel

    protected int getTargetLabel()

#### getCurrentLabel

    protected int getCurrentLabel()

#### setCurrentLabel

    protected void setCurrentLabel(int label)

#### grow

    protected void grow()

#### rewindPrefix

    protected final void rewindPrefix()
                               throws IOException

Rewinds enum state to match the shared prefix between current term and target term

Throws:
  `IOException`

#### doNext

    protected void doNext()
                   throws IOException

Throws:
  `IOException`

#### doSeekCeil

    protected void doSeekCeil()
                       throws IOException

Seeks to smallest term that's >= target.

Throws:
  `IOException`

#### doSeekFloor

    protected void doSeekFloor()
                        throws IOException

Seeks to largest term that's <= target.

Throws:
  `IOException`

#### doSeekExact

    protected boolean doSeekExact()
                           throws IOException

Seeks to exactly target term.

Throws:
  `IOException`