## org.apache.lucene.util
Class PagedBytes.Reader

    java.lang.Object
      org.apache.lucene.util.PagedBytes.Reader

Enclosing class:
  PagedBytes

    public static final class PagedBytes.Reader

extends Object

Provides methods to read BytesRefs from a frozen PagedBytes.

See Also:
  `PagedBytes.freeze(boolean)`

Constructor Summary
`PagedBytes.Reader(PagedBytes pagedBytes)`

Method Summary
`BytesRef` `fill(BytesRef b, long start)` Reads length as 1 or 2 byte vInt prefix, starting at start.
`int` `fillAndGetIndex(BytesRef b, long start)` Reads length as 1 or 2 byte vInt prefix, starting at start.
`long` `fillAndGetStart(BytesRef b, long start)` Reads length as 1 or 2 byte vInt prefix, starting at start and returns the start offset of the next part, suitable as start parameter on next call to sequentially read all `BytesRef`.
`BytesRef` `fillSlice(BytesRef b, long start, int length)` Gets a slice out of `PagedBytes` starting at start with a given length.
`BytesRef` `fillSliceWithPrefix(BytesRef b, long start)` Gets a slice out of `PagedBytes` starting at start, the length is read as 1 or 2 byte vInt prefix.
`int[]` `getBlockEnds()`
`byte[][]` `getBlocks()`

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

Constructor Detail

### PagedBytes.Reader

    public PagedBytes.Reader(PagedBytes pagedBytes)

Method Detail

### fillSlice

    public BytesRef fillSlice(BytesRef b,
                              long start,
                              int length)

  Gets a slice out of `PagedBytes` starting at start with a given length. Iff the slice spans across a block border this method will allocate sufficient resources and copy the paged data.

  Slices spanning more than one block are not supported.

  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

### fill

    public BytesRef fill(BytesRef b,
                         long start)

  Reads length as 1 or 2 byte vInt prefix, starting at start.

  Note: this method does not support slices spanning across block borders.

  Returns:
    the given `BytesRef`
  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

### fillAndGetIndex

    public int fillAndGetIndex(BytesRef b,
                               long start)

  Reads length as 1 or 2 byte vInt prefix, starting at start. *

  Note: this method does not support slices spanning across block borders.

  Returns:
    the internal block number of the slice.
  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

### fillAndGetStart

    public long fillAndGetStart(BytesRef b,
                                long start)

  Reads length as 1 or 2 byte vInt prefix, starting at start and returns the start offset of the next part, suitable as start parameter on next call to sequentially read all `BytesRef`.

  Note: this method does not support slices spanning across block borders.

  Returns:
    the start offset of the next part, suitable as start parameter on next call to sequentially read all `BytesRef`.
  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

### fillSliceWithPrefix

    public BytesRef fillSliceWithPrefix(BytesRef b,
                                        long start)

  Gets a slice out of `PagedBytes` starting at start, the length is read as 1 or 2 byte vInt prefix. Iff the slice spans across a block border this method will allocate sufficient resources and copy the paged data.

  Slices spanning more than one block are not supported.

  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

### getBlocks

    public byte[][] getBlocks()

  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

### getBlockEnds

    public int[] getBlockEnds()

  NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.