AbstractPagedInputView (Paimon : Common 0.6.0-incubating API)

java.lang.Object
- org.apache.paimon.data.AbstractPagedInputView

所有已实现的接口:

DataInput, DataInputView

直接已知子类:

CachedRandomInputView, RandomAccessInputView
```
public abstract class AbstractPagedInputView
extends Object
implements DataInputView
```
The base class for all input views that are backed by multiple memory pages. This base class contains all decoding methods to read data from a page and detect page boundary crossing. The concrete sub classes must implement the methods to provide the next memory page once the boundary is crossed.

构造器概要

构造器
限定符	构造器和说明
`protected`	`AbstractPagedInputView()` Creates a new view that is initially not bound to a memory segment.
`protected`	`AbstractPagedInputView(MemorySegment initialSegment, int initialLimit)` Creates a new view that starts with the given segment.

方法概要

所有方法实例方法抽象方法具体方法
限定符和类型	方法和说明
`void`	`advance()` Advances the view to the next memory segment.
`protected void`	`clear()` Clears the internal state of the view.
`protected void`	`doAdvance()`
`int`	`getCurrentPositionInSegment()` Gets the position from which the next byte will be read.
`MemorySegment`	`getCurrentSegment()` Gets the memory segment that will be used to read the next bytes from.
`int`	`getCurrentSegmentLimit()` Gets the current limit in the memory segment.
`protected abstract int`	`getLimitForSegment(MemorySegment segment)` Gets the limit for reading bytes from the given memory segment.
`protected abstract MemorySegment`	`nextSegment(MemorySegment current)` The method by which concrete subclasses realize page crossing.
`int`	`read(byte[] b)` Tries to fill the given byte array `b`.
`int`	`read(byte[] b, int off, int len)` Reads up to `len` bytes of memory and stores it into `b` starting at offset `off`.
`boolean`	`readBoolean()`
`byte`	`readByte()`
`char`	`readChar()`
`double`	`readDouble()`
`float`	`readFloat()`
`void`	`readFully(byte[] b)`
`void`	`readFully(byte[] b, int off, int len)`
`int`	`readInt()`
`String`	`readLine()`
`long`	`readLong()`
`short`	`readShort()`
`int`	`readUnsignedByte()`
`int`	`readUnsignedShort()`
`String`	`readUTF()`
`protected void`	`seekInput(MemorySegment segment, int positionInSegment, int limitInSegment)` Sets the internal state of the view such that the next bytes will be read from the given memory segment, starting at the given position.
`int`	`skipBytes(int n)`
`void`	`skipBytesToRead(int numBytes)` Skips `numBytes` bytes of memory.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - AbstractPagedInputView
```
protected AbstractPagedInputView(MemorySegment initialSegment,
                                 int initialLimit)
```
    Creates a new view that starts with the given segment. The input starts directly after the header of the given page. If the header size is zero, it starts at the beginning. The specified initial limit describes up to which position data may be read from the current segment, before the view must advance to the next segment.
    
    参数:
    
    initialSegment - The memory segment to start reading from.
    
    initialLimit - The position one after the last valid byte in the initial segment.
  - AbstractPagedInputView
```
protected AbstractPagedInputView()
```
    Creates a new view that is initially not bound to a memory segment. This constructor is typically for views that always seek first.
    WARNING: The view is not readable until the first call to either advance(), or to seekInput(MemorySegment, int, int).
- 方法详细资料
  - getCurrentSegment
```
public MemorySegment getCurrentSegment()
```
    Gets the memory segment that will be used to read the next bytes from. If the segment is exactly exhausted, meaning that the last byte read was the last byte available in the segment, then this segment will not serve the next bytes. The segment to serve the next bytes will be obtained through the nextSegment(MemorySegment) method.
    
    返回:
    
    The current memory segment.
  - getCurrentPositionInSegment
```
public int getCurrentPositionInSegment()
```
    Gets the position from which the next byte will be read. If that position is equal to the current limit, then the next byte will be read from next segment.
    
    返回:
    
    The position from which the next byte will be read.
    
    另请参阅:
    
    getCurrentSegmentLimit()
  - getCurrentSegmentLimit
```
public int getCurrentSegmentLimit()
```
    Gets the current limit in the memory segment. This value points to the byte one after the last valid byte in the memory segment.
    
    返回:
    
    The current limit in the memory segment.
    
    另请参阅:
    
    getCurrentPositionInSegment()
  - nextSegment
```
protected abstract MemorySegment nextSegment(MemorySegment current)
                                      throws EOFException,
                                             IOException
```
    The method by which concrete subclasses realize page crossing. This method is invoked when the current page is exhausted and a new page is required to continue the reading. If no further page is available, this method must throw an EOFException.
    
    参数:
    
    current - The current page that was read to its limit. May be null, if this method is invoked for the first time.
    
    返回:
    
    The next page from which the reading should continue. May not be null. If the input is exhausted, an EOFException must be thrown instead.
    
    抛出:
    
    EOFException - Thrown, if no further segment is available.
    
    IOException - Thrown, if the method cannot provide the next page due to an I/O related problem.
  - getLimitForSegment
```
protected abstract int getLimitForSegment(MemorySegment segment)
```
    Gets the limit for reading bytes from the given memory segment. This method must return the position of the byte after the last valid byte in the given memory segment. When the position returned by this method is reached, the view will attempt to switch to the next memory segment.
    
    参数:
    
    segment - The segment to determine the limit for.
    
    返回:
    
    The limit for the given memory segment.
  - advance
```
public void advance()
             throws IOException
```
    Advances the view to the next memory segment. The reading will continue after the header of the next segment. This method uses nextSegment(MemorySegment) and getLimitForSegment(MemorySegment) to get the next segment and set its limit.
    
    抛出:
    
    IOException - Thrown, if the next segment could not be obtained.
    
    另请参阅:
    
    nextSegment(MemorySegment), getLimitForSegment(MemorySegment)
  - doAdvance
```
protected void doAdvance()
                  throws IOException
```
    抛出:
    
    IOException
  - seekInput
```
protected void seekInput(MemorySegment segment,
                         int positionInSegment,
                         int limitInSegment)
```
    Sets the internal state of the view such that the next bytes will be read from the given memory segment, starting at the given position. The memory segment will provide bytes up to the given limit position.
    
    参数:
    
    segment - The segment to read the next bytes from.
    
    positionInSegment - The position in the segment to start reading from.
    
    limitInSegment - The limit in the segment. When reached, the view will attempt to switch to the next segment.
  - clear
```
protected void clear()
```
    Clears the internal state of the view. After this call, all read attempts will fail, until the advance() or seekInput(MemorySegment, int, int) method have been invoked.
  - read
```
public int read(byte[] b)
         throws IOException
```
    从接口复制的说明: DataInputView
    
    Tries to fill the given byte array b. Returns the actually number of read bytes or -1 if there is no more data.
    
    指定者:
    
    read 在接口中 DataInputView
    
    参数:
    
    b - byte array to store the data to
    
    返回:
    
    the number of read bytes or -1 if there is no more data left
    
    抛出:
    
    IOException
  - read
```
public int read(byte[] b,
                int off,
                int len)
         throws IOException
```
    从接口复制的说明: DataInputView
    
    Reads up to len bytes of memory and stores it into b starting at offset off. It returns the number of read bytes or -1 if there is no more data left.
    
    指定者:
    
    read 在接口中 DataInputView
    
    参数:
    
    b - byte array to store the data to
    
    off - offset into byte array
    
    len - byte length to read
    
    返回:
    
    the number of actually read bytes of -1 if there is no more data left
    
    抛出:
    
    IOException
  - readFully
```
public void readFully(byte[] b)
               throws IOException
```
    指定者:
    
    readFully 在接口中 DataInput
    
    抛出:
    
    IOException
  - readFully
```
public void readFully(byte[] b,
                      int off,
                      int len)
               throws IOException
```
    指定者:
    
    readFully 在接口中 DataInput
    
    抛出:
    
    IOException
  - readBoolean
```
public boolean readBoolean()
                    throws IOException
```
    指定者:
    
    readBoolean 在接口中 DataInput
    
    抛出:
    
    IOException
  - readByte
```
public byte readByte()
              throws IOException
```
    指定者:
    
    readByte 在接口中 DataInput
    
    抛出:
    
    IOException
  - readUnsignedByte
```
public int readUnsignedByte()
                     throws IOException
```
    指定者:
    
    readUnsignedByte 在接口中 DataInput
    
    抛出:
    
    IOException
  - readShort
```
public short readShort()
                throws IOException
```
    指定者:
    
    readShort 在接口中 DataInput
    
    抛出:
    
    IOException
  - readUnsignedShort
```
public int readUnsignedShort()
                      throws IOException
```
    指定者:
    
    readUnsignedShort 在接口中 DataInput
    
    抛出:
    
    IOException
  - readChar
```
public char readChar()
              throws IOException
```
    指定者:
    
    readChar 在接口中 DataInput
    
    抛出:
    
    IOException
  - readInt
```
public int readInt()
            throws IOException
```
    指定者:
    
    readInt 在接口中 DataInput
    
    抛出:
    
    IOException
  - readLong
```
public long readLong()
              throws IOException
```
    指定者:
    
    readLong 在接口中 DataInput
    
    抛出:
    
    IOException
  - readFloat
```
public float readFloat()
                throws IOException
```
    指定者:
    
    readFloat 在接口中 DataInput
    
    抛出:
    
    IOException
  - readDouble
```
public double readDouble()
                  throws IOException
```
    指定者:
    
    readDouble 在接口中 DataInput
    
    抛出:
    
    IOException
  - readLine
```
public String readLine()
                throws IOException
```
    指定者:
    
    readLine 在接口中 DataInput
    
    抛出:
    
    IOException
  - readUTF
```
public String readUTF()
               throws IOException
```
    指定者:
    
    readUTF 在接口中 DataInput
    
    抛出:
    
    IOException
  - skipBytes
```
public int skipBytes(int n)
              throws IOException
```
    指定者:
    
    skipBytes 在接口中 DataInput
    
    抛出:
    
    IOException
  - skipBytesToRead
```
public void skipBytesToRead(int numBytes)
                     throws IOException
```
    从接口复制的说明: DataInputView
    
    Skips numBytes bytes of memory. In contrast to the DataInput.skipBytes(int) method, this method always skips the desired number of bytes or throws an EOFException.
    
    指定者:
    
    skipBytesToRead 在接口中 DataInputView
    
    参数:
    
    numBytes - The number of bytes to skip.
    
    抛出:
    
    IOException - Thrown, if any I/O related problem occurred such that the input could not be advanced to the desired position.

类 AbstractPagedInputView

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

AbstractPagedInputView

AbstractPagedInputView

方法详细资料

getCurrentSegment

getCurrentPositionInSegment

getCurrentSegmentLimit

nextSegment

getLimitForSegment

advance

doAdvance

seekInput

clear

read

read

readFully

readFully

readBoolean

readByte

readUnsignedByte

readShort

readUnsignedShort

readChar

readInt

readLong

readFloat

readDouble

readLine

readUTF

skipBytes

skipBytesToRead