All Classes and Interfaces
Class
Description
Skeletal base for hand-written (“custom”) binary type handlers.
Skeletal base for handlers of collection-like types — types that hold a variable number of
references and therefore have variable persisted length per instance.
Skeletal base for handlers of types that implement
Iterable.Skeletal base for handlers of iterable types that persist their elements as a single simple binary list
at offset 0 (no header fields, no per-element key/value structure).
Skeletal base for handlers of iterable types backed by a sized array (capacity-bearing arrays whose
occupied portion can be smaller than the array length, e.g.
Skeletal base for handlers of mutable types that hold no references — e.g.
Specialization of
AbstractBinaryHandlerCustomNonReferential for non-referencing types whose
persisted form has a fixed length (e.g.Skeletal base for handlers of immutable value types (e.g.
Specialization of
AbstractBinaryHandlerCustomValue for value types whose persisted form has a
fixed length (e.g.Specialization of
AbstractBinaryHandlerCustomValue for value types whose persisted form has a
variable length (e.g.Generic abstract class for specialized handler for
java.util.ImmutableCollections.Set12 and java.util.ImmutableCollections.List12
in JDK 15 and later
The handler takes the internal constant java.util.ImmutableCollections.EMPTY into account which must not be persisted.
The handler takes the internal constant java.util.ImmutableCollections.EMPTY into account which must not be persisted.
Skeletal base for binary type handlers that derive their persistent layout reflectively from the fields
of the handled class.
Skeletal base for
AbstractBinaryHandlerCustom subclasses whose handled type carries no
persistent state.Skeletal base for handlers of types that have neither persistable state nor any references — e.g.
Skeletal base for reflective legacy type handlers: applies value translators directly into the in-memory
field offsets of an already-instantiated object.
Skeletal base for
BinaryLegacyTypeHandler implementations that reconstruct instances by
translating persisted legacy values into the layout expected by a current
PersistenceTypeHandler.Central abstraction of the binary persistence layer's storing- and loading-side data view: a
length-prefixed sequence of entities, each with an [length, type id, object id] header followed by its
persisted content.
Functional supplier for the number of parallel channels the binary persistence layer should partition
its work across.
Functional callback used by collection-like binary handlers to read a single element entry from a
persisted list at the given offset within the surrounding entity's binary form.
Reads a buffer of concatenated entity binary data, each entity preceded by its header (length, type id,
object id).
Functional callback invoked by
BinaryEntityRawDataIterator for each entity encountered while
scanning a raw memory range.Walks a contiguous raw memory range containing concatenated binary items (entities and skip-comments)
and dispatches each entity to a
BinaryEntityRawDataAcceptor.Default
BinaryEntityRawDataIterator implementation that walks length-prefixed binary items.Pluggable factory for
BinaryEntityRawDataIterator instances, kept on the foundation so the
iteration strategy can be swapped without touching call sites.Default
BinaryEntityRawDataIterator.Provider that yields a fresh BinaryEntityRawDataIterator.New() on each call.Declarative description of a single persisted field for a
CustomBinaryHandler-based handler.Registry of per-
Field BinaryFieldStorerCreators and BinaryFieldSetterCreators
consulted by reflective binary handlers when they need a custom storage or load strategy for a
particular field.Default implementation of BinaryFieldHandlerProvider interface.
Binary-specific specialization of
PersistenceFieldLengthResolver.Default
BinaryFieldLengthResolver.BinaryFieldSetter are custom implementations of BinaryValueSetter
for a specific field.
BinaryFieldSetterCreator implementations are responsible to create
BinaryFieldSetter for a specific field of a class.
BinaryFieldStorer are custom implementations of BinaryValueStorer
for a specific field.
BinaryFieldStorerCreator implementations are responsible to create
BinaryFieldStorer for a specific field of a class.
Built-in
BinaryFieldStorerCreator for Throwable.stackTrace.Nearly identical to
BinaryHandlerLazyDefault except
the handled type.Specialized handler for immutable List implementations in Java 15 and later
as found in java.util.ImmutableCollections.List12
the implementations are returned from List.of(), List.of(E e1) and List.of(E e1, E e2)
The handler takes the internal constant java.util.ImmutableCollections.EMPTY into account which must not be persisted.
the implementations are returned from List.of(), List.of(E e1) and List.of(E e1, E e2)
The handler takes the internal constant java.util.ImmutableCollections.EMPTY into account which must not be persisted.
Specialized handler for immutable Set implementations in Java 15 and later
as found in java.util.ImmutableCollections.Set12
the implementations are returned from Set.of(), Set.of(E e1) and Set.of(E e1, E e2)
The handler takes the internal constant java.util.ImmutableCollections.EMPTY into account which must not be persisted.
the implementations are returned from Set.of(), Set.of(E e1) and Set.of(E e1, E e2)
The handler takes the internal constant java.util.ImmutableCollections.EMPTY into account which must not be persisted.
Binary Handler for java.time.LocalDate
Required for java ≥ 26 because of transient fields and
changed binary format of YearMonth implementation.
Binary Handler for java.time.MonthDay
Required for java ≥ 26 because of transient fields and
changed binary format of MonthDay implementation.
This type handler cannot handle a
Properties' defaults values.Binary Handler for private class "java.util.Collections$SetFromMap"
Blunt copy of
BinaryHandlerDate for the as good as superfluous type Date.Blunt copy of
BinaryHandlerDate for the as good as superfluous type Time.Blunt copy of
BinaryHandlerDate for the as good as superfluous type Timestamp.Binary Handler for java.time.YearMonth
Required for java ≥ 26 because of transient fields and
changed binary format of YearMonth implementation.
Binary-specific specialization of
PersistenceLegacyTypeHandler that handles loading of entities
persisted under an outdated type definition.Skeletal base for
BinaryLegacyTypeHandler implementations that work directly off a
PersistenceTypeDefinition and do not need the full AbstractBinaryHandlerCustom
machinery.Skeletal base for hand-written legacy
BinaryLegacyTypeHandler implementations that reuse the
AbstractBinaryHandlerCustom infrastructure (member declarations, helper methods, etc.).Binary-specific specialization of
PersistenceLegacyTypeHandlerCreator.Default
BinaryLegacyTypeHandlerCreator implementation.Reflective legacy handler for enum classes whose static structure (the set and order of enum
constants) has not changed since the legacy version.
Reflective legacy handler for enum classes whose static structure (the set or order of enum
constants) has changed since the legacy version.
Generic reflective legacy handler for non-enum classes: applies the per-member value translators directly
into the in-memory field offsets of an instance produced by the wrapped current
PersistenceTypeHandlerReflective.Legacy type handler that, for each persisted entity, allocates a fresh native buffer, copies translated
values from the legacy layout into the offsets of the current layout, and reroutes the load item to
point at the new buffer before delegating instance creation, state update, and completion to the wrapped
current
PersistenceTypeHandler.Binary-specific specialization of
PersistenceLegacyTypeHandlerSupplier that supplies
BinaryLegacyTypeHandler instances for outdated type definitions encountered during loading.Binary-specific specialization of
PersistenceLoader: drives a single load operation by
collecting required object ids into a LoadItemsChain, fetching the corresponding entity data
from a PersistenceSourceSupplier, instantiating each entity via the registered
BinaryTypeHandler, and finally wiring up references through the registered
PersistenceObjectRegistry.Pluggable factory for
BinaryLoader instances.Multi-channel
BinaryLoader.Creator: produces loaders backed by a
LoadItemsChain.ChannelHashing, partitioning queued object ids across the configured number
of channels for parallel fetching from a channel-partitioned source.Single-channel
BinaryLoader.Creator: produces loaders backed by a LoadItemsChain.Simple,
suitable for sources that are not channel-partitioned.Default
BinaryLoader implementation.Per-entity scratchpad used by the binary loader during a single load operation.
BinaryLoadItem variant for sources whose persisted form uses a non-native byte order.Static facade for the binary persistence layer.
Factory and master configuration type for assembling a binary persistence layer.
Default
BinaryPersistenceFoundation implementation.Binary-specific specialization of
PersistenceRootsProvider.Default
BinaryPersistenceRootsProvider implementation.Walks the persisted binary form of a member (or a contiguous run of members) and reports any references
it contains to a
PersistenceObjectIdAcceptor.Binary-specific specialization of
PersistenceStorer: collects entities into per-channel
ChunksBuffers, assigns object ids via the surrounding PersistenceObjectManager, and
flushes the assembled data to a PersistenceTarget on commit().A lazy storer with batching support designed for write-heavy operations.
Pluggable factory for
BinaryStorer instances.Skeletal
BinaryStorer.Creator base holding the channel-count provider and byte-order flag shared by
all created storers.Default
BinaryStorer.Creator implementation.Default implementation that stores referenced instances only if required (i.e. if they have no OID assigned yet,
therefore have not been stored yet, therefore require to be stored).
Identical to
For a more differentiated solution between the two simple, but extreme strategies, see
BinaryStorer.Default, but stores every referenced instance eagerly.For a more differentiated solution between the two simple, but extreme strategies, see
PersistenceEagerStoringFieldEvaluator.Static catalog of singleton
BinaryValueStorer and BinaryValueSetter instances for every
built-in primitive and reference value flavor (native and byte-reversed, eager and non-eager,
skipping).Reads a single persisted value from binary memory and writes it into a target instance (or, for
absolute-addressing callers, into raw target memory).
Reads a single value from a source instance's memory and writes it into the binary form at a target
memory address.
Strategy for building the lookup key that selects a custom
BinaryValueSetter from the
BinaryValueTranslatorProvider's registered translator map.Read-only view onto a (source-type, target-type) →
BinaryValueSetter mapping.Since the value translator lookup might potentially get rather giant in the future, it is wrapped in a trivial
on-demand provider to ensure it is really only created (and held in memory forever) if necessary.
Default
BinaryValueTranslatorMappingProvider.Resolves the
BinaryValueSetter that translates a persisted source member's value to either the
matching current target member (instance-update path) or to the corresponding slot in a rewritten
intermediate binary form (rerouting path).Default
BinaryValueTranslatorProvider implementation.Static factory and registry for
BinaryValueSetters used during legacy type mapping to translate
a persisted source value into the layout of a current target member.Aggregation of one or more direct
ByteBuffers that together hold a contiguous logical block of
persisted binary data.Storing-side
Binary implementation: collects entities into a growable array of direct
ByteBuffers, allocating a fresh buffer (sized by the supplied
BufferSizeProviderIncremental) whenever the current one runs out of room.ChunksBuffer variant that stores all primitive values in a non-native byte order.Loading-side
Binary implementation: wraps an array of already-filled direct ByteBuffers
read from a source so they can be iterated as a single logical chunk.ChunksWrapper variant for sources whose persisted form uses a non-native byte order.Internal data structure used by the binary loader to gather the set of object ids whose data still needs
to be fetched from the source.
Skeletal base providing the dedup hash table; subclasses supply the linked-list bookkeeping that
decides how queued ids are partitioned for
LoadItemsChain.getObjectIdSets().Multi-channel
LoadItemsChain: distributes queued ids across channelCount chains via
the low bits of the object id, yielding one PersistenceIdSet per channel for parallel
fetching from a channel-partitioned source.Single-channel
LoadItemsChain: yields one PersistenceIdSet containing all queued ids
in insertion order.Functional callback that reads a contiguous range of native memory starting at a raw address.