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
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `IntsRefFSTEnum.InputOutput<T>` Holds a single input (IntsRef) + output pair.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `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

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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`

Copyright © 2000-2018 Apache Software Foundation. All Rights Reserved.