BytesCommon (OpenHFT/Java-Lang/lang 6.6.7 API)

All Known Subinterfaces:

Bytes, ByteStringAppender, ByteStringParser, IByteBufferBytes, RandomDataInput, RandomDataOutput

All Known Implementing Classes:

AbstractBytes, BoundsCheckingDirectBytes, BoundsCheckingNativeBytes, ByteBufferBytes, CheckedBytes, DirectByteBufferBytes, DirectBytes, MappedNativeBytes, MultiStoreBytes, NativeBytes, VanillaMappedBytes, WrappedBytes
```
public interface BytesCommon
```
Author:

peter.lawrey

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`alignPositionAddr(int alignment)` Align the position address to a power of 2.
`ByteOrder`	`byteOrder()`
`long`	`capacity()`
`void`	`checkEndOfBuffer()`
`Bytes`	`clear()` Clears this buffer.
`void`	`finish()` Mark the end of the message if writing and check we are at the end of the message if reading.
`Bytes`	`flip()` Flips this buffer.
`InputStream`	`inputStream()`
`boolean`	`isFinished()`
`long`	`limit()`
`Bytes`	`limit(long limit)`
`Bytes`	`load()` Access every page to ensure those pages are in memory.
`ObjectSerializer`	`objectSerializer()`
`OutputStream`	`outputStream()`
`long`	`position()`
`Bytes`	`position(long position)`
`long`	`remaining()`
`Bytes`	`slice()` Creates a new bytes whose content is a shared subsequence of this bytes' content.
`Bytes`	`slice(long offset, long length)` Creates a new bytes whose content is a shared subsequence of this bytes' content.
`ByteBuffer`	`sliceAsByteBuffer(ByteBuffer toReuse)` Returns a `ByteBuffer` whose content is a shared subsequence of this bytes' content.
`String`	`toDebugString()`
`String`	`toDebugString(long limit)`
`void`	`toString(Appendable sb, long start, long position, long end)` Write a portion of the Bytes to an Appendable for printing.

- Method Detail
  - position
```
long position()
```
    Returns:
    the offset read/written which must be >= limit()
  - position
```
Bytes position(long position)
               throws IllegalArgumentException
```
    Parameters:
    position - to skip to
    
    Returns:
    this bytes object back
    
    Throws:
    
    IllegalArgumentException - if positions < 0 || position >= limit
  - limit
```
long limit()
```
    Returns:
    the current limit which must be >= capacity()
  - limit
```
Bytes limit(long limit)
```
    Parameters:
    limit - the new limit which must be >= capacity()
    
    Returns:
    this bytes object back
  - capacity
```
long capacity()
```
    Returns:
    space available
  - remaining
```
long remaining()
```
    Returns:
    space remaining in bytes
  - finish
```
void finish()
            throws IndexOutOfBoundsException
```
    Mark the end of the message if writing and check we are at the end of the message if reading.
    
    Throws:
    
    IndexOutOfBoundsException - if too much data was written.
  - isFinished
```
boolean isFinished()
```
    Returns:
    has finish been called.
  - clear
```
Bytes clear()
```
    Clears this buffer. The position is set to zero, the limit is set to the capacity, and the mark is discarded.
    Invoke this method before using a sequence of channel-read or put operations to fill this buffer. For example:
```
buf.clear();     // Prepare buffer for reading
 in.read(buf);    // Read data
 
```
    This method does not actually erase the data in the buffer, but it is named as if it did because it will most often be used in situations in which that might as well be the case.
    Returns:
    This buffer
  - flip
```
Bytes flip()
```
    Flips this buffer. The limit is set to the current position and then the position is set to zero. If the mark is defined then it is discarded.
    After a sequence of channel-read or put operations, invoke this method to prepare for a sequence of channel-write or relative get operations. For example:
```
buf.put(magic);    // Prepend header
 in.read(buf);      // Read data into rest of buffer
 buf.flip();        // Flip buffer
 out.write(buf);    // Write header + data to channel
 
```
    This method is often used in conjunction with the compact method when transferring data from one place to another.
    Returns:
    This buffer
  - byteOrder
```
@NotNull
ByteOrder byteOrder()
```
    Returns:
    Byte order for reading binary
  - inputStream
```
@NotNull
InputStream inputStream()
```
    Returns:
    these Bytes as an InputStream
  - outputStream
```
@NotNull
OutputStream outputStream()
```
    Returns:
    these Bytes as an OutputStream
  - objectSerializer
```
@NotNull
ObjectSerializer objectSerializer()
```
    Returns:
    the factory for marshallers.
  - checkEndOfBuffer
```
void checkEndOfBuffer()
                      throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException - if the bounds of the Bytes has been exceeded.
  - load
```
Bytes load()
```
    Access every page to ensure those pages are in memory.
    
    Returns:
    this.
  - toString
```
void toString(Appendable sb,
            long start,
            long position,
            long end)
```
    Write a portion of the Bytes to an Appendable for printing.
    
    Parameters:
    sb - to append to
    start - first byte
    position - where to place a cursor or 0 = none.
    end - last byte to append.
  - alignPositionAddr
```
void alignPositionAddr(int alignment)
```
    Align the position address to a power of 2.
    
    Parameters:
    alignment - power of 2 to align to.
  - slice
```
Bytes slice()
```
    Creates a new bytes whose content is a shared subsequence of this bytes' content.
    The content of the new bytes will start at this bytes' current position. Changes to this bytes' content will be visible in the new bytes, and vice versa; the two bytes' position and limit values will be independent.
    The new bytes' position will be zero, its capacity and its limit will be the number of bytes remaining in this bytes.
    slice() is equivalent of slice(0, remaining()).
    
    Returns:
    the new bytes
    See Also:
    slice(long, long)
  - sliceAsByteBuffer
```
ByteBuffer sliceAsByteBuffer(@Nullable
                           ByteBuffer toReuse)
```
    Returns a ByteBuffer whose content is a shared subsequence of this bytes' content.
    The content of the returned ByteBuffer will start at this bytes' current position. Changes to this bytes' content will be visible in the returned ByteBuffer, and vice versa; this bytes' and the returned ByteBuffer's position and limit values will be independent.
    The returned ByteBuffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this bytes.
    If this bytes object is able to reuse to given toReuse ByteBuffer, it will be reused and returned back from this method, otherwise a new ByteBuffer instance is created and returned.
    
    Parameters:
    toReuse - a ByteBuffer to reuse
    
    Returns:
    a ByteBuffer view of this Bytes
    See Also:
    slice(), ByteBuffer.slice()
  - slice
```
Bytes slice(long offset,
          long length)
```
    Creates a new bytes whose content is a shared subsequence of this bytes' content.
    The content of the new bytes will start at this bytes' current position()+ offset. Changes to this bytes' content will be visible in the new bytes, and vice versa; the two bytes' position and limit values will be independent.
    The new bytes' position will be zero, its capacity and its limit will be equal to length.
    offset can be negative (if current bytes' position is positive) and length can run out of current bytes' limit, the restriction is that new bytes' should be within this bytes' absolute bounds.
    
    Parameters:
    offset - relative offset of the new bytes from the current bytes' position
    length - capacity of the new bytes
    
    Returns:
    the new bytes
    See Also:
    slice()
  - toDebugString
```
@NotNull
String toDebugString()
```
  - toDebugString
```
String toDebugString(long limit)
```

Interface BytesCommon

Method Summary

Method Detail

position

position

limit

limit

capacity

remaining

finish

isFinished

clear

flip

byteOrder

inputStream

outputStream

objectSerializer

checkEndOfBuffer

load

toString

alignPositionAddr

slice

sliceAsByteBuffer

slice

toDebugString

toDebugString