Package net.openhft.chronicle.bytes

The Chronicle Bytes package provides low-level memory access wrappers with functionalities akin to Java NIO's ByteBuffer.

See: Description

Interface Summary

Interface	Description
BinaryWireCode	The BinaryWireCode interface contains constants for various types of data expected in a binary wire protocol.
Byteable<B extends BytesStore<B,U>,U>	An interface for a reference to off-heap memory, acting as a proxy for memory residing outside the heap.
Bytes<U>	The Bytes class is a versatile container for raw byte data, providing rich functionality to read and write data in various formats including integers, longs, floating-point values, strings, and more.
BytesConsumer	A functional interface for consuming bytes.
BytesContext	Defines a context for operating with bytes.
BytesIn<U>	Defines an interface for reading bytes.
BytesMarshallable	An interface for objects that can be read from and written to bytes in a streaming manner.
BytesMethodWriterInvocationHandler	Interface for an invocation handler that provides a mechanism to handle the closure of resources.
BytesOut<U>	This interface represents an output stream for writing data to bytes.
BytesParselet	Functional interface representing a parselet for processing byte data.
BytesPrepender<B extends BytesPrepender<B>>	An interface defining a prependable buffer of bytes.
BytesRingBuffer	This interface represents a ring buffer data structure capable of reading and writing Bytes (binary data).
BytesRingBufferStats	This interface provides statistics about a BytesRingBuffer.
BytesStore<B extends BytesStore<B,U>,U>	This interface represents an immutable reference to a segment of bytes with a fixed range.
ByteStringAppender<B extends ByteStringAppender<B>>	This interface provides methods for appending different types of data to an underlying buffer.
ByteStringParser<B extends ByteStringParser<B>>	An interface that provides support for parsing bytes as text.
CommonMarshallable	Defines common behavior for marshallable objects, i.e., objects that can be converted to and from a series of bytes.
DistributedUniqueTimeDeduplicator
DynamicallySized	An interface that indicates an implementor of Byteable has dynamic size requirements.
HexDumpBytesDescription<B extends HexDumpBytesDescription<B>>	This interface is for additional description to be added to HexDumpBytes
Invocation	Functional interface representing an invocation of a method.
MappedBytesStoreFactory	A functional interface that serves as a factory for creating instances of MappedBytesStore.
MethodEncoder	Interface defining the required operations for a method encoder.
MethodReader	Interface defining the required operations for a method reader.
MethodReaderBuilder	Interface for a builder that constructs instances of MethodReader.
MethodReaderInterceptorReturns	Functional interface representing an interceptor for methods invoked through a MethodReader.
MethodWriterBuilder<T>	Interface for creating a builder that will generate a MethodWriter instance of a specific type.
MethodWriterInterceptorReturns	Functional interface representing an interceptor for methods invoked through a MethodWriter.
MethodWriterInvocationHandler	Interface for handling invocations in a MethodWriter.
MultiReaderBytesRingBuffer	Extension of the BytesRingBuffer interface that supports multiple readers.
NewChunkListener	Functional interface defining a listener that gets invoked when a new chunk is added to a MappedFile in MappedBytes.
OffsetFormat	Functional interface defining a format for appending offset information to a byte sequence.
RandomDataInput	The RandomDataInput class provides a series of methods for reading data from various types of inputs.
RandomDataOutput<R extends RandomDataOutput<R>>	The RandomDataOutput interface provides a set of methods for writing data to a buffer or similar data structure at arbitrary positions (offsets).
ReadBytesMarshallable	Functional interface to facilitate the reading of data directly as Bytes.
RingBufferReader	An interface for a reader on a Ring Buffer, providing methods to read and navigate through the buffer.
RingBufferReaderStats	An interface to provide statistics about a RingBufferReader's reading operations.
StopCharsTester	A functional interface that defines a strategy for identifying stop characters during a string parsing operation.
StopCharTester	A functional interface for defining a strategy to identify stop characters during string parsing.
StreamingCommon<S extends StreamingCommon<S>>	Represents a streaming interface for handling streaming data with support for random access.
StreamingDataInput<S extends StreamingDataInput<S>>	The StreamingDataInput interface represents a data stream for reading in binary data.
StreamingDataOutput<S extends StreamingDataOutput<S>>	StreamingDataOutput is an interface for classes that support writing data to a stream.
UpdateInterceptor	Represents an operation that intercepts a method call, possibly modifies the input argument, and determines whether to proceed with the original operation.
WriteBytesMarshallable	An interface defining a contract for serializing data directly to a Bytes instance.

Class Summary

Class	Description
AbstractBytes<U>	Abstract representation of Bytes.
BinaryBytesMethodWriterInvocationHandler	Invocation handler that encodes method invocations as binary data written to a BytesOut.
BytesMarshaller<T>	This class is used to marshal objects into bytes and unmarshal them from bytes.
BytesMethodReader	The BytesMethodReader class provides a concrete implementation of the MethodReader interface.
BytesMethodReaderBuilder	Concrete implementation of MethodReaderBuilder for constructing BytesMethodReader instances.
BytesTextMethodTester<T>	The BytesTextMethodTester class is a utility for comparing the expected and actual results of executing a method from a given interface that manipulates bytes.
DistributedUniqueTimeProvider	A TimeProvider implementation that ensures unique timestamps across multiple systems using a predefined hostId.
GuardedNativeBytes<U>	This class extends the NativeBytes class and provides an additional layer of safety by tracking the raw primitives written to the byte buffer.
HexDumpBytes	A class that implements the Bytes interface for generating a hex dump of byte data.
MappedBytes	A specialized implementation of AbstractBytes that wraps memory-mapped data for efficient random file access.
MappedBytesStore	A BytesStore implementation that wraps memory-mapped data.
MappedFile	Represents a memory-mapped file that can be randomly accessed in chunks.
NativeBytes<U>	NativeBytes is a subclass of VanillaBytes which can wrap either a ByteBuffer or malloc'ed memory.
OnHeapBytes
PageUtil	Provides file systems' page size auto-resolving.
PointerBytesStore	A BytesStore that points to arbitrary memory.
StreamingInputStream	A special kind of InputStream implementation which reads data from a StreamingDataInput instance.
StreamingOutputStream	A special kind of OutputStream implementation which writes data to a StreamingDataOutput instance.
SubBytes<U>	A SubBytes object represents a subsection of a BytesStore from a given start index up to a specified capacity.
UncheckedBytes<U>	An optimized extension of AbstractBytes that doesn't perform any bounds checking for read and write operations.
UncheckedNativeBytes<U>	An optimized extension of AbstractBytes that performs unchecked read and write operations on a Bytes instance that is backed by native memory.
VanillaBytes<U>	A simple Bytes implementation that is non-elastic.

Enum Summary

Enum	Description
AppendableUtil	Utility class for working with Appendable objects such as StringBuilder and Bytes.
BytesUtil	Utility class for performing operations on Bytes and related data types.
MappedUniqueTimeProvider	Provides timestamps that are guaranteed to be unique across threads and processes on a single machine.
MethodEncoderLookup	Enum singleton that implements Function interface to lookup and return a MethodEncoder for a given method.
StopCharTesters	A collection of predefined StopCharTester implementations that define common stop character criteria.
SyncMode	An enumeration of sync modes for disk operations.

Exception Summary

Exception	Description
ConnectionDroppedException	Exception thrown when the TcpChannelHub loses its connection to the server.
UTFDataFormatRuntimeException	An unchecked exception thrown when there is an issue with encoding or decoding UTF-8 data.

Annotation Types Summary

Annotation Type	Description
FieldGroup	Annotation used for logically grouping fields within a class.
MethodId	Annotation that denotes a method as having a numeric identifier for efficient encoding.

Package net.openhft.chronicle.bytes Description

The Chronicle Bytes package provides low-level memory access wrappers with functionalities akin to Java NIO's ByteBuffer. The API supports UTF-8 and ISO-8859-1 encoded strings, thread-safe off-heap memory operations, deterministic release of resources via reference counting, and more.

The main classes in this package are:

Bytes: A class for managing byte arrays, including operations for reading and writing data. It extends if you write data into it which is larger than its real capacity. It provides access to the cursors for reading and writing data at desired indices.

BytesStore: A block of memory with fixed size into which you can write data and later read. You cannot use the cursors with a BytesStore, unlike Bytes.

BytesIn: Interface that provides a range of methods for reading data from bytes.

BytesOut: Interface that provides a range of methods for writing data to bytes.

ByteStringParser: An interface for parsing byte strings.

ByteStringAppender: An interface for appending byte strings.

RandomDataInput: An interface that extends the StreamingDataInput.

RandomDataOutput: An interface that extends the StreamingDataOutput.

StreamingDataInput: An interface for reading data from a stream.

StreamingDataOutput: An interface for writing data to a stream.

For more information, please refer to each class documentation.