## org.apache.lucene.search.spans
Class NearSpansUnordered

    java.lang.Object
      org.apache.lucene.search.spans.Spans
          org.apache.lucene.search.spans.NearSpansUnordered

    public class NearSpansUnordered

extends Spans

Similar to `NearSpansOrdered`, but for the unordered case. Expert: Only public for subclassing. Most implementations should not need this class

Constructor Summary
`NearSpansUnordered(SpanNearQuery query, IndexReader reader)`

Method Summary
`int` `doc()` Returns the document number of the current match.
`int` `end()` Returns the end position of the current match.
`Collection<byte[]>` `getPayload()` WARNING: The List is not necessarily in order of the the positions
`Spans[]` `getSubSpans()`
`boolean` `isPayloadAvailable()` Checks if a payload can be loaded at this position.
`boolean` `next()` Move to the next match, returning true iff any such exists.
`boolean` `skipTo(int target)` Skips to the first match beyond the current, whose document number is greater than or equal to target.
`int` `start()` Returns the start position of the current match.
`String` `toString()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### NearSpansUnordered

    public NearSpansUnordered(SpanNearQuery query,
                              IndexReader reader)
                       throws IOException

Throws:
  `IOException`

Method Detail

### getSubSpans

    public Spans[] getSubSpans()

### next

    public boolean next()
                 throws IOException

  Description copied from class: `Spans`
  Move to the next match, returning true iff any such exists.

  Specified by:
    `next` in class `Spans`
  Throws:
    `IOException`

### skipTo

    public boolean skipTo(int target)
                   throws IOException

  Description copied from class: `Spans`
  Skips to the first match beyond the current, whose document number is greater than or equal to target.

  Returns true iff there is such a match.

  Behaves as if written:

         boolean skipTo(int target) {
           do {
             if (!next())
                   return false;
           } while (target > doc());
           return true;
         }

  Most implementations are considerably more efficient than that.

  Specified by:
    `skipTo` in class `Spans`
  Throws:
    `IOException`

### doc

    public int doc()

  Description copied from class: `Spans`
  Returns the document number of the current match. Initially invalid.

  Specified by:
    `doc` in class `Spans`

### start

    public int start()

  Description copied from class: `Spans`
  Returns the start position of the current match. Initially invalid.

  Specified by:
    `start` in class `Spans`

### end

    public int end()

  Description copied from class: `Spans`
  Returns the end position of the current match. Initially invalid.

  Specified by:
    `end` in class `Spans`

### getPayload

    public Collection<byte[]> getPayload()
                                  throws IOException

  WARNING: The List is not necessarily in order of the the positions

  Specified by:
    `getPayload` in class `Spans`
  Returns:
    Collection of `byte[]` payloads
  Throws:
    `IOException`

### isPayloadAvailable

    public boolean isPayloadAvailable()

  Description copied from class: `Spans`
  Checks if a payload can be loaded at this position.

  Payloads can only be loaded once per call to `Spans.next()`.

  Specified by:
    `isPayloadAvailable` in class `Spans`
  Returns:
    true if there is a payload available at this position that can be loaded

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`