@InterfaceAudience.Private @InterfaceStability.Evolving public abstract class AbstractPositionedByteRange extends AbstractByteRange implements PositionedByteRange
SimpleByteRange implementation with position
support. position is considered transient, not fundamental to the
definition of the range, and does not participate in
AbstractByteRange.compareTo(ByteRange), AbstractByteRange.hashCode(), or
Object.equals(Object). Position is retained by copy operations.| Modifier and Type | Field and Description |
|---|---|
protected int |
limit |
protected int |
position
The current index into the range.
|
bytes, hash, length, offset, UNSET_HASH_VALUE| Constructor and Description |
|---|
AbstractPositionedByteRange() |
| Modifier and Type | Method and Description |
|---|---|
abstract PositionedByteRange |
deepCopy()
Create a new
ByteRange with new backing byte[] containing a copy
of the content from this range's window. |
byte |
get()
Retrieve the next byte from this range.
|
PositionedByteRange |
get(byte[] dst)
Fill
dst with bytes from the range, starting from position. |
PositionedByteRange |
get(byte[] dst,
int offset,
int length)
Fill
dst with bytes from the range, starting from the current
position. |
PositionedByteRange |
get(int index,
byte[] dst)
Fill
dst with bytes from the range, starting from index. |
PositionedByteRange |
get(int index,
byte[] dst,
int offset,
int length)
Fill
dst with bytes from the range, starting from index. |
int |
getInt()
Retrieve the next int value from this range.
|
int |
getLimit()
Return the current limit
|
long |
getLong()
Retrieve the next long value from this range.
|
int |
getPosition()
The current
position marker. |
int |
getRemaining()
The number of bytes remaining between position and the end of the range.
|
short |
getShort()
Retrieve the next short value from this range.
|
long |
getVLong()
Retrieve the next long value, which is stored as VLong, from this range
|
byte |
peek()
Retrieve the next byte from this range without incrementing position.
|
abstract PositionedByteRange |
put(byte val)
Store
val at the next position in this range. |
abstract PositionedByteRange |
put(byte[] val)
Store the content of
val in this range, starting at the next position. |
abstract PositionedByteRange |
put(byte[] val,
int offset,
int length)
Store
length bytes from val into this range. |
abstract PositionedByteRange |
put(int index,
byte val)
Store
val at index. |
abstract PositionedByteRange |
put(int index,
byte[] val)
Store
val at index. |
abstract PositionedByteRange |
put(int index,
byte[] val,
int offset,
int length)
Store
length bytes from val into this range, starting at
index. |
abstract PositionedByteRange |
putInt(int val)
Store int
val at the next position in this range. |
abstract PositionedByteRange |
putInt(int index,
int val)
Store the int value at
index |
abstract PositionedByteRange |
putLong(int index,
long val)
Store the long value at
index |
abstract PositionedByteRange |
putLong(long val)
Store long
val at the next position in this range. |
abstract PositionedByteRange |
putShort(int index,
short val)
Store the short value at
index |
abstract PositionedByteRange |
putShort(short val)
Store short
val at the next position in this range. |
abstract int |
putVLong(int index,
long val)
Store the long value at
index as a VLong |
abstract int |
putVLong(long val)
Store the long
val at the next position as a VLong |
PositionedByteRange |
set(byte[] bytes)
Reuse this
ByteRange over a new byte[]. |
PositionedByteRange |
set(byte[] bytes,
int offset,
int length)
Reuse this
ByteRange over a new byte[]. |
PositionedByteRange |
set(int capacity)
Reuse this
ByteRange over a new byte[]. |
PositionedByteRange |
setLength(int length)
Update the length of this range.
|
PositionedByteRange |
setLimit(int limit)
Limits the byte range upto a specified value.
|
PositionedByteRange |
setOffset(int offset)
Update the beginning of this range.
|
PositionedByteRange |
setPosition(int position)
Update the
position index. |
abstract PositionedByteRange |
shallowCopy()
Create a new
ByteRange that points at this range's byte[]. |
abstract PositionedByteRange |
shallowCopySubRange(int innerOffset,
int copyLength)
Create a new
ByteRange that points at this range's byte[]. |
abstract PositionedByteRange |
unset()
Nullifies this ByteRange.
|
clearHashCache, compareTo, deepCopySubRangeTo, deepCopyTo, deepCopyToNewArray, get, getBytes, getInt, getLength, getLong, getOffset, getShort, getVLong, getVLongSize, hashCode, isEmpty, isEmpty, isHashCached, toStringclone, equals, finalize, getClass, notify, notifyAll, wait, wait, waitdeepCopySubRangeTo, deepCopyTo, deepCopyToNewArray, get, getBytes, getInt, getLength, getLong, getOffset, getShort, getVLong, isEmptycompareToprotected int position
ByteBuffer position, it
points to the next value that will be read/written in the array. It
provides the appearance of being 0-indexed, even though its value is
calculated according to offset.
Position is considered transient and does not participate in
Object.equals(Object) or AbstractByteRange.hashCode() comparisons.
protected int limit
public abstract PositionedByteRange unset()
ByteRangeunset in interface ByteRangeunset in interface PositionedByteRangeunset in class AbstractByteRangepublic PositionedByteRange set(int capacity)
ByteRangeByteRange over a new byte[]. offset is set to
0 and length is set to capacity.set in interface ByteRangeset in interface PositionedByteRangeset in class AbstractByteRangecapacity - the size of a new byte[].public PositionedByteRange set(byte[] bytes)
ByteRangeByteRange over a new byte[]. offset is set to
0 and length is set to bytes.length. A null bytes
IS supported, in which case this method will behave equivalently to
ByteRange.unset().set in interface ByteRangeset in interface PositionedByteRangeset in class AbstractByteRangebytes - the array to wrap.public PositionedByteRange set(byte[] bytes, int offset, int length)
ByteRangeByteRange over a new byte[]. A null bytes IS
supported, in which case this method will behave equivalently to
ByteRange.unset(), regardless of the values of offset and
length.set in interface ByteRangeset in interface PositionedByteRangeset in class AbstractByteRangebytes - The array to wrap.offset - The offset into bytes considered the beginning of
this range.length - The length of this range.public PositionedByteRange setOffset(int offset)
offset + length may not be
greater than bytes.length. Resets position to 0.setOffset in interface ByteRangesetOffset in interface PositionedByteRangesetOffset in class AbstractByteRangeoffset - the new start of this range.public PositionedByteRange setLength(int length)
offset + length should not be
greater than bytes.length. If position is greater than the
new length, sets position to length.setLength in interface ByteRangesetLength in interface PositionedByteRangesetLength in class AbstractByteRangelength - The new length of this range.public int getPosition()
PositionedByteRangeposition marker. This valuae is 0-indexed, relative to
the beginning of the range.getPosition in interface PositionedByteRangepublic PositionedByteRange setPosition(int position)
PositionedByteRangeposition index. May not be greater than length.setPosition in interface PositionedByteRangeposition - the new position in this range.public int getRemaining()
PositionedByteRangegetRemaining in interface PositionedByteRangepublic byte peek()
PositionedByteRangepeek in interface PositionedByteRangepublic byte get()
PositionedByteRangeget in interface PositionedByteRangepublic PositionedByteRange get(byte[] dst)
PositionedByteRangedst with bytes from the range, starting from position.
This range's position is incremented by the length of dst,
the number of bytes copied.get in interface PositionedByteRangedst - the destination of the copy.public PositionedByteRange get(byte[] dst, int offset, int length)
PositionedByteRangedst with bytes from the range, starting from the current
position. length bytes are copied into dst,
starting at offset. This range's position is incremented
by the number of bytes copied.get in interface PositionedByteRangedst - the destination of the copy.offset - the offset into dst to start the copy.length - the number of bytes to copy into dst.public abstract PositionedByteRange put(byte val)
PositionedByteRangeval at the next position in this range.put in interface PositionedByteRangeval - the new value.public abstract PositionedByteRange put(byte[] val)
PositionedByteRangeval in this range, starting at the next position.put in interface PositionedByteRangeval - the new value.public abstract PositionedByteRange put(byte[] val, int offset, int length)
PositionedByteRangelength bytes from val into this range. Bytes from
val are copied starting at offset into the range, starting at
the current position.put in interface PositionedByteRangeval - the new value.offset - the offset in val from which to start copying.length - the number of bytes to copy from val.public abstract PositionedByteRange putInt(int index, int val)
ByteRangeindexputInt in interface ByteRangeputInt in interface PositionedByteRangeputInt in class AbstractByteRangeindex - the index in the range where val is storedval - the value to storepublic abstract PositionedByteRange putLong(int index, long val)
ByteRangeindexputLong in interface ByteRangeputLong in interface PositionedByteRangeputLong in class AbstractByteRangeindex - the index in the range where val is storedval - the value to storepublic abstract PositionedByteRange putShort(int index, short val)
ByteRangeindexputShort in interface ByteRangeputShort in interface PositionedByteRangeputShort in class AbstractByteRangeindex - the index in the range where val is storedval - the value to storepublic abstract PositionedByteRange putInt(int val)
PositionedByteRangeval at the next position in this range.putInt in interface PositionedByteRangeval - the new value.public abstract PositionedByteRange putLong(long val)
PositionedByteRangeval at the next position in this range.putLong in interface PositionedByteRangeval - the new value.public abstract PositionedByteRange putShort(short val)
PositionedByteRangeval at the next position in this range.putShort in interface PositionedByteRangeval - the new value.public abstract int putVLong(int index,
long val)
ByteRangeindex as a VLongputVLong in interface ByteRangeputVLong in class AbstractByteRangeindex - the index in the range where val is storedval - the value to storepublic abstract int putVLong(long val)
PositionedByteRangeval at the next position as a VLongputVLong in interface PositionedByteRangeval - the value to storepublic PositionedByteRange get(int index, byte[] dst)
ByteRangedst with bytes from the range, starting from index.get in interface ByteRangeget in interface PositionedByteRangeget in class AbstractByteRangeindex - zero-based index into this range.dst - the destination of the copy.public PositionedByteRange get(int index, byte[] dst, int offset, int length)
ByteRangedst with bytes from the range, starting from index.
length bytes are copied into dst, starting at offset.get in interface ByteRangeget in interface PositionedByteRangeget in class AbstractByteRangeindex - zero-based index into this range.dst - the destination of the copy.offset - the offset into dst to start the copy.length - the number of bytes to copy into dst.public short getShort()
PositionedByteRangegetShort in interface PositionedByteRangepublic int getInt()
PositionedByteRangegetInt in interface PositionedByteRangepublic long getLong()
PositionedByteRangegetLong in interface PositionedByteRangepublic long getVLong()
PositionedByteRangegetVLong in interface PositionedByteRangepublic abstract PositionedByteRange put(int index, byte val)
ByteRangeval at index.put in interface ByteRangeput in interface PositionedByteRangeput in class AbstractByteRangeindex - the index in the range where val is stored.val - the value to store.public abstract PositionedByteRange put(int index, byte[] val)
ByteRangeval at index.put in interface ByteRangeput in interface PositionedByteRangeput in class AbstractByteRangeindex - the index in the range where val is stored.val - the value to store.public abstract PositionedByteRange put(int index, byte[] val, int offset, int length)
ByteRangelength bytes from val into this range, starting at
index. Bytes from val are copied starting at offset
into the range.put in interface ByteRangeput in interface PositionedByteRangeput in class AbstractByteRangeindex - position in this range to start the copy.val - the value to store.offset - the offset in val from which to start copying.length - the number of bytes to copy from val.public abstract PositionedByteRange deepCopy()
ByteRangeByteRange with new backing byte[] containing a copy
of the content from this range's window.deepCopy in interface ByteRangedeepCopy in interface PositionedByteRangepublic abstract PositionedByteRange shallowCopy()
ByteRangeByteRange that points at this range's byte[].
Modifying the shallowCopy will modify the bytes in this range's array.
Pass over the hash code if it is already cached.shallowCopy in interface ByteRangeshallowCopy in interface PositionedByteRangeByteRange object referencing this range's byte[].public abstract PositionedByteRange shallowCopySubRange(int innerOffset, int copyLength)
ByteRangeByteRange that points at this range's byte[]. The new
range can have different values for offset and length, but modifying the
shallowCopy will modify the bytes in this range's array. Pass over the
hash code if it is already cached.shallowCopySubRange in interface ByteRangeshallowCopySubRange in interface PositionedByteRangeinnerOffset - First byte of clone will be this.offset + copyOffset.copyLength - Number of bytes in the clone.ByteRange object referencing this range's byte[].public PositionedByteRange setLimit(int limit)
PositionedByteRangesetLimit in interface PositionedByteRangepublic int getLimit()
PositionedByteRangegetLimit in interface PositionedByteRange