All Classes and Interfaces
Class
Description
Configuration base for config types with a factory class and its properties.
Base class for
CacheConfigCommon configuration shared by authentication modules provided out-of-the box in Hazelcast.
A common abstract superclass for
DiscoveryStrategy implementations,
offering convenient access to configuration properties (which may be overridden
on the system's environment or JVM properties), as well as a ILogger instance.Configuration base for config types with a factory class and its properties.
Base class of all Hazelcast BeanDefinitionParser implementations.
Base Helper class for Spring Xml Builder
The abstract class for a map event
IMapEvent.An abstract
LoadBalancer implementation.Abstract
ILogger implementation that provides implementations for convenience methods like
finest, info, warning and severe.The common parent for
ConfigReplacer implementations which allow to mask values by encrypting the value.Base class to implement custom processors.
Base class for symmetric encryption configuration classes.
Base class for WAN publisher configuration.
Contains logic for replacing system variables in the XML file and importing XML files from different locations.
Contains Hazelcast XML Configuration helper methods and variables.
Contains logic for replacing system variables in the YAML file and importing YAML files from different locations.
Service for pluggable authentication and authorization.
AccessControlService configuration.
Interface implemented by
AccessControlService factory classes.Represents an address of a member in the cluster.
This is a client side utility class for working with addresses and cluster connections
Similar to
NetworkConfig with the additional ability to define multiple
endpoints, each with its own separate protocol/security and/or socket properties.Member endpoint decorated as a
NetworkConfig
Facade used during bootstrap to hide if-logic between the two networking configuration approachesOffers a step-by-step API to build a pipeline stage that co-aggregates
the data from several input stages.
Offers a step-by-step API to build a pipeline stage that co-aggregates
the data from several input stages.
Contains primitives needed to compute an aggregated result of data
processing.
Specialization of
AggregateOperation (refer to its extensive documentation) to the "arity-1" case with
a single data stream being aggregated over.Specialization of
AggregateOperation (refer to its extensive documentation) to the "arity-2" case with
two data streams being aggregated over.Specialization of
AggregateOperation (refer to its extensive documentation) to the "arity-3" case with
three data streams being aggregated over.A builder object that can be used to construct the definition of an
aggregate operation in a step-by-step manner.
The arity-1 variant of the aggregate operation builder.
The arity-2 variant of the aggregate operation builder.
The arity-3 variant of the aggregate operation builder.
The variable-arity variant of the aggregate operation builder.
Utility class with factory methods for several useful aggregate
operations.
Defines a contract for all aggregators.
A utility class to create basic
Aggregator instances.Configuration for discovery strategy aliases, e.g.
Offers a step-by-step API to create a composite of multiple aggregate
operations.
A traverser with an internal
ArrayDeque.An exception which indicates that an assertion passed successfully.
Various assertions which can be used to assert items passing through the
pipeline for correctness.
Various assertions which can be used to assert items on the output of a
pipeline.
Contains the configuration of a custom attribute that will be extracted from a Map's entry using a given ValueExtractor.
Observable event in the system.
Auditlog configuration.
Service for logging
AuditableEvents.Interface implemented by
AuditlogService factory classes.Auditable event type identifiers.
This interface represents authentication configuration in a security realm.
Interface for authentication context objects used by
AccessControlService implementations.A
HazelcastException that is thrown when there is an Authentication failure: e.g.Interface for authorization context objects, It's used by
AccessControlService implementations.Configuration for the Discovery Strategy Auto Detection.
The
AutoDisposableTask interface should be implemented by any single run task
which is to be destroyed automatically after executionFileFormat for avro files.Static utility class with factories of Apache Avro source and sink
processors.
Contains factory methods for Apache Avro sinks.
Builder for an Avro file source that reads records from Avro files in a
directory (but not its subdirectories) and emits objects returned by
mapOutputFn.Contains factory methods for Apache Avro sources.
The AWSConfig contains the configuration for AWS join mechanism.
AWS implementation of
DiscoveryStrategy.Factory class which returns
AwsDiscoveryStrategy to Discovery SPIConfiguration for the Azure Discovery Strategy.
Azure implementation of
DiscoveryStrategyFactory class which returns
AzureDiscoveryStrategy to Discovery SPIAn invocable function that allows applications to perform compound operations
on a
Cache.Entry atomically, according to the defined
consistency of a Cache.The state of the persistence backup task
The status of the persistence backup task, including progress and state.
Base interface for Hazelcast distributed maps.
Base class of configuration options specific to metrics collection.
Base interface for Hazelcast distributed multi-maps.
Base interface for Hazelcast distributed queues.
A finite source of data for a Jet pipeline.
A stage in a distributed computation
pipeline that will
observe a finite amount of data (a batch).An intermediate step while constructing a group-and-aggregate batch
pipeline stage.
An element annotated with this annotation is considered beta status.
Serializable variant of java.util.function.BiConsumer which declares checked exception.Serializable variant of java.util.function.BiFunction which declares checked exception.Serializable variant of java.util.function.BinaryOperator which declares checked exception.Serializable variant of java.util.function.BiPredicate which declares checked exception.Configures indexing options specific to bitmap indexes.
Defines an assortment of transformations which can be applied to
unique key values.Marks a key in the snapshot state to indicate that the
corresponding entry should be broadcast to all processors
when restoring the snapshot.
Configuration options specific for B-Tree indexes.
For sample usage custom serialization and other way of custom serialization
see
StreamSerializer.Contains all the configuration for the
ICache.Accessor for package-private methods of
CacheConfig.Mutable extension to
CompleteConfigurationControl caching of de-serialized values.
Entry info for cache record.
Hazelcast JCache implementation's internal event types.
Bean definition parser for JCache
CacheManager.This exception class is thrown while creating
CacheRecordStore
instances but the cache config does not exist on the node to create the instance on.Configuration for CachePartitionLostListener
Simple configuration to hold parsed XML configuration.
Represents configuration for "ExpiryPolicyFactory".
Represents duration configuration with duration amount and time unit
for the "TimedExpiryPolicyFactoryConfig".
Represents configuration for time based "ExpiryPolicyFactory" with duration and time unit.
Represents type of the "TimedExpiryPolicyFactoryConfig".
Simple configuration to hold parsed listener config.
Cache statistics
Utility class for various cache related operations to be used by our internal structure and end user.
A
RetryableHazelcastException that indicates that an operation was sent by a machine which isn't member
in the cluster when the operation is executed.A
CPSubsystemException which is thrown when an entry cannot be
replicated, which can occur in one of the following cases:
a member leaves the CP group
CP group itself is terminated
uncommitted entry count reaches to
(see RaftAlgorithmConfig.getUncommittedEntryCountToRejectNewAppends())
a membership change is requested before an entry is committed
on a term
Capacity represents a memory capacity with given value and
MemoryUnitCardinalityEstimator is a redundant and highly available distributed
data-structure used for probabilistic cardinality estimation purposes,
on unique items, in significantly sized data cultures.
Configuration options for the
CardinalityEstimatorContains factory methods for change data capture specific pipeline
sinks.
Information pertaining to a single data change event (insert, delete or
update), affecting a single database record.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Holds blacklist and whitelist configuration in java deserialization configuration.
Allows to intercept class resolution during deserialization based on classname.
A
Config which is initialized by loading an XML configuration file from the classpath.A
Config which is initialized by loading a YAML configuration file from the classpath.The Client interface allows to get information about
a connected client's socket address, type and UUID.
A
ClientConfig which is initialized by loading an XML configuration file from the classpath.A
ClientConfig which is initialized by loading an YAML configuration file from the classpath.hazelcast.cloud configuration to let the client connect the cluster via hazelcast.cloud
Main configuration to setup a Hazelcast Client
ConfigRecognizer implementation that recognizes Hazelcast
client declarative configurations based on an extensible set of
built-in ConfigRecognizer implementations.The ClientConfigXmlGenerator is responsible for transforming a
ClientConfig to a Hazelcast Client XML string.Client connection strategy configuration is used for setting custom strategies and configuring strategy parameters.
Reconnect options.
A
ClientFailoverConfig which is initialized by loading an XML
configuration file from the classpath.A
ClientFailoverConfig which is initialized by loading a YAML
configuration file from the classpath.Config class to configure multiple client configs to be used by single client instance.
ConfigRecognizer implementation that recognizes Hazelcast
client failover declarative configurations based on an extensible set
of built-in ConfigRecognizer implementations.The
ClientFlakeIdGeneratorConfig contains the configuration for the client
regarding Flake ID Generator.Configuration for icmp ping failure detector of clients.
The ClientListener provides the ability to listen to clients connecting and disconnecting from the member.
Client-side metrics collection configuration.
Contains configuration parameters for client network related behaviour
A
HazelcastException that is thrown when the client can not use a cluster.To clear resources of the client upon OutOfMemory
Defines the name and default value for Hazelcast Client properties.
Contains the ReliableTopic configuration for a client.
Contains the security configuration for the client.
ClientService allows you to query connected
Clients and
attach/detach ClientListeners to listen to connection events.Contains the SQL configuration for the client.
The configuration when to retry query that fails with reasons:
SqlErrorCode.CONNECTION_PROBLEM
SqlErrorCode.PARTITION_DISTRIBUTION
SqlErrorCode.TOPOLOGY_CHANGE
SqlErrorCode.RESTARTABLE_ERROR
Helper class for the user to track the lifecycle state of the client.
Contains client configurations for TPC.
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.4, "User Code Deployment" is replaced by the "User Code Namespaces" feature
Hazelcast cluster interface.
Defines the name and default value for Hazelcast properties.
ClusterState are several possible states of the cluster
where each state can allow and/or deny specific actions
and/or change behavior of specific actions.Offers a step-by-step API to create an aggregate operation that
accepts multiple inputs.
Provides configuration service for Collection.
Provides means of reading Compact serialized fields from the binary data.
In 5.0, this feature is disabled by default and has to be enabled via
configuration
An accessor for the package-private fields of the
CompactSerializationConfig.Defines the contract of the serializers used for Compact serialization.
Provides means of writing compact serialized fields to the binary data.
Serializable variant of java.util.Comparator
which declares checked exception.Hazelcast internal callbacks shouldn't use the
ForkJoinPool#commonPool, due to the risk of blocking
Hazelcast progress by other misbehaving applications/libraries.Contains all the configuration to start a
HazelcastInstance.Private API for accessing configuration at runtime
Interface for all config builders.
Provides factory methods for
Config and ClientConfig.The ConfigPatternMatcher provides a strategy to match an item name
to a configuration pattern.
Interface for recognizing a declarative Hazelcast configuration
based on the rules defined in the actual implementation.
Interface to be implemented by pluggable variable replacers for the configuration files.
Stream wrapping or copying a generic
InputStream for the
ConfigRecognizer API.The ConfigXmlGenerator is responsible for transforming a
Config to a Hazelcast XML string.Utility class to build xml using a
StringBuilder.Connection Retry Config is controls the period among the retries and when should a client gave up
retrying.
Strategy for checking the consistency of data between replicas.
Exception that indicates that the consistency guarantees provided by
some service has been lost.
Special thanks to Alexandre Vasseur for providing this very nice test application.
Serializable variant of java.util.function.Consumer
which declares checked exception.Contains information about a CP group.
Represents status of a CP group
CPGroupAvailabilityEvent is published when a CP group's
availability is decreased or it has lost the majority completely.
CPGroupAvailabilityListener is notified when availability
of a CP group decreases or it loses the majority completely.
A
CPSubsystemException which is thrown when a request is sent to
a destroyed CP group.Identifier for CP groups.
CPMap is a key-value store within CP.
Configuration for
CPMap.A CP member is a Hazelcast member that is internally elected to be part of
the
CPSubsystem, hence maintain CP data structures.CPMembershipEvent is published when a CP member is added to
or removed from the CP Subsystem.
Membership event type.
CPMembershipListener is notified when a CP member is added to
or removed from the CP Subsystem.
Info (name, serviceName, group) about a CP object
Represents a CP session.
Represents type of endpoints that create CP sessions
This interface offers API for managing CP sessions.
CP Subsystem is a component of Hazelcast that builds a strongly consistent
layer for a set of distributed data structures.
Contains configuration options for CP Subsystem.
Base exception for failures in CP Subsystem
This interface offers APIs for managing CP members and groups.
Configures the replication mechanism for all
CRDT implementations.Credentials represents an identity to be authenticated.
Contains the configuration for Credentials Factory.
Identity configuration which just holds given credentials instance.
FileFormat for CSV files.Describes a computation to be performed by the Jet computation engine.
DataConnection is a reference to a single external system.
Base class for
DataConnection implementations.Validates an instance of
DataConnectionConfig.Represents a reference to the data connection, used with
Sources.jdbc(DataConnectionRef, ToResultSetFunction, FunctionEx).Registration for a
DataConnection.DataConnection Resource is an object for which a mapping can be created.
The interface provides access to
DataConnections for Jet processors.Configures the Persistence per Hazelcast data structure.
DataSerializable is a serialization method alternative to standard Java
serialization.
DataSerializableFactory is used to create IdentifiedDataSerializable instances during de-serialization.
Contains factory methods for creating Change Data Capture (CDC) sources.
A builder to configure a CDC source that streams the change data from
a Debezium-supported database to Hazelcast Jet.
Default
AuthenticationConfig implementation which just references the DefaultLoginModule.A
PartitioningStrategy that checks if the key implements PartitionAware.A facade that hides the details of Hazelcast partitioning SPI and exposes
just the partitioning strategy.
Contains a configuration change for
JobConfig.Hook to decouple Hazelcast object from the tenant
Device configuration for the Tiered-Store
Static utility class with factories of sinks and wrappers that log
the data flowing through the DAG.
Merges only entries from the destination data structure and discards all entries from the source data structure.
This configuration class describes the top-level config of the discovery
SPI and its discovery strategies.
The
DiscoveryMode describes how the DiscoveryStrategy is going
to behave on discovery requests.A
DiscoveryNode describes a nodes addresses (private and if
necessary a public one) as well as attributes assigned to this node.The
DiscoveryService interface defines the basic entry point
into the Discovery SPI implementation.The
DiscoveryServiceProvider interface provides the possibility to build DiscoveryServices.The
DiscoveryServiceSettings class is used to pass the necessary
configuration to create a DiscoveryService to the
DiscoveryServiceProvider.The
DiscoveryStrategy itself is the actual implementation to discover
nodes based on whatever environment is used to run the Hazelcast cloud.This configuration class describes a
DiscoveryStrategy
based on a parsed XML or configured manually using the config APIThe
DiscoveryStrategyFactory is the entry point for strategy vendors.Level of the discovery strategy.
Disk tier configuration of Tiered-Store.
Base interface for all distributed objects.
A
HazelcastException that indicates that a DistributedObject
access was attempted, but the object is destroyed.DistributedObjectEvent is fired when a
DistributedObject
is created or destroyed cluster-wide.Type of the DistributedObjectEvent.
DistributedObjectListener notifies when a
DistributedObject
is created or destroyed cluster-wide.Utility class for
DistributedObject.Accumulator of a
double value.An exception thrown when a task's name is already used before for another (or the same, if re-attempted) schedule.
Contains the configuration for an
DurableExecutorService.Durable implementation of
ExecutorService.A Future where one can obtain the task ID for tracking the response.
Dynamic Configuration related configuration options.
Echoes to screen.
An edge describes a connection from many upstream processors to many
downstream processors.
A configuration object for a DAG
Edge
that holds fine-tuning parameters that influence its performance
characteristics.Collection of convenience factory methods for Elastic's
RestClientBuilderBuilder for Elasticsearch Sink
Provides factory methods for Elasticsearch sinks.
Builder for Elasticsearch source which reads data from Elasticsearch and
converts SearchHits using provided
mapToItemFnProvides factory methods for Elasticsearch sources.
Originally taken from JBOSS project (thanks guys, great work)
Original class: org.jboss.osgi.metadata.spi.ElementParser -> JBossOSGi Resolver Metadata
Contains configuration for the Hot Restart Persistence at Rest encryption
This class is an example
ConfigReplacer implementation which decrypts
encrypted values.Endpoint represents a peer in the cluster.
Endpoint configuration that defines communication/networking properties common to both incoming/outgoing connections
eg.
Adapter for
MapListener.Invoked upon addition of an entry.
Map Entry event.
Type of entry event.
Invoked upon size-based-eviction of an entry.
Invoked upon expiration-based removal of an entry.
Map Entry listener to get notified when a map entry is added,
removed, updated, evicted or expired.
Configuration for
EntryListenerInvoked upon load of an entry.
This is an extension to
MapLoader.Represents a value with an expiration time attached to it.
Invoked after WAN replicated entry is merged.
An EntryProcessor processes a
Map.Entry.Invoked upon removal of an entry.
This is an extension to
MapStore.Invoked upon update of an entry.
Represents a read-only view of a data structure entry.
Configuration for the Eureka Discovery Strategy.
Builder interface for
AuditableEvent instances.The event for the cache event journal.
Configuration for an event journal.
The event for the map event journal.
This event is fired in case of an event lost detection.
Invoked upon lost of event or events.
A utility that helps a source emit events according to a given
EventTimePolicy.A holder of functions and parameters Jet needs to handle event time and the
associated watermarks.
Contract point (from the end user perspective)
for serving/accessing entries that can be evicted.
Configuration for eviction.
Eviction Policy enum.
A kind of
Comparator to be
used while comparing entries to be evicted.Indicates that the annotated class, method or interface has stable
implementation but its API may change between minor versions.
ExecutionCallback allows to asynchronously get notified when the execution is completed,
either successfully or with error.
Contains the configuration for an
IExecutorService.Merges data structure entries from source to destination data structure if the source entry
will expire later than the destination entry.
Interface to provide parity with IMap set and put operations.
A linearizable & distributed & reentrant implementation of
Lock.Contains configuration options for
FencedLockDefines the name, type and index of a field.
Field Type for
Portable format to be used with ClassDefinition.getFieldType(String) APIDescribes the data format of a file to be used as a Jet data source.
A unified builder object for various kinds of file sources.
Builder for a file source which reads lines from files in a directory (but not
its subdirectories) and emits output object created by
mapOutputFnContains factory methods for the Unified File Connector.
A
Config which includes functionality for loading itself from a
XML configuration file.A
Config which includes functionality for loading itself from a
YAML configuration file.A cluster-wide unique ID generator.
The
FlakeIdGeneratorConfig contains the configuration for the member
regarding Flake ID Generator.Serializable variant of java.util.function.Function
which declares checked exception.Factory methods for several common functions.
Configuration for the GCP Discovery Strategy.
GCP implementation of
DiscoveryStrategy.Factory class which returns
GcpDiscoveryStrategy to Discovery SPI.Offers a step-by-step fluent API to build a hash-join pipeline stage.
An intermediate step when constructing a group-and-aggregate pipeline
stage.
A function which takes a timestamp and a sequence number as the input.
GenericMapLoader is an implementation of
MapLoader built
on top of Hazelcast SQL engine.GenericMapStore is an implementation of
MapStore built
on top of Hazelcast SQL engine.Interface for creating
GenericRecord instances.Contains the configuration for global serializer.
Offers a step-by-step API to build a pipeline stage that co-groups and
aggregates the data from several input stages.
Offers a step-by-step API to build a pipeline stage that co-groups and
aggregates the data from several input stages.
Properties of the grpc module
Represents a gRPC service that can be used as part of a
mapUsingServiceAsync call.Provides
ServiceFactory implementations for calling gRPC
endpoints.Static utility class with factories of Apache Hadoop Hadoop source and sink
processors.
Factories of Apache Hadoop sinks.
Contains factory methods for Apache Hadoop sources.
Offers a step-by-step fluent API to build a hash-join pipeline stage.
Factory for
HazelcastInstance's, a node in a cluster.Spring related
Cache implementation for Hazelcast.Contract point of Hazelcast cache manager implementations (client + server)
based on
CacheManager.Spring-related
CacheManager implementation for Hazelcast.Hazelcast implementation of JCache
CachingProvider.The HazelcastClient is comparable to the
Hazelcast class and provides the ability
the create and manage Hazelcast clients.BeanDefinitionParser for Hazelcast Client Configuration.
Client bean definition builder
Client-side
CachingProvider implementation.Thrown when Hazelcast client is not active during an invocation.
Thrown when Hazelcast client is offline during an invocation.
BeanDefinitionParser for Hazelcast Config Configuration.
Creates a HazelcastInstance that is shared to connect to a remote cluster.
Base Hazelcast exception.
Hazelcast provides overloads of the typical cache operations with a custom
This class provides a custom implementation of an
ExpiryPolicy parameter.This class provides a custom implementation of an
ExpiryPolicy to
react on all three types of policies:
Create
Access
Update
BeanDefinitionParser for Hazelcast Client Configuration.
Hazelcast instance.
Used to get HazelcastInstance reference when submitting a Runnable/Callable using Hazelcast ExecutorService.
This JAAS
Callback is used to retrieve the current HazelcastInstance.BeanDefinitionParser for Hazelcast Instance Configuration.
Thrown when HazelcastInstance is not active during an invocation.
HazelcastJsonValue is a wrapper for JSON formatted strings.
An Avro deserializer for Kafka.
An Avro serializer for Kafka.
Just the factory to create the Kubernetes Discovery Strategy
Prevents duplicate copies of the Apache License.
This transformer implementation is used to merge MANIFEST and OSGi
bundle metadata in conjunction with the Maven Shade plugin when
integrating multiple dependencies into one output JAR.
Member-side
CachingProvider implementation.Hazelcast Custom Namespace Definitions.
Contract point for
HazelcastInstance implementations based on OSGi service.Contract point for Hazelcast services on top of OSGI.
A
HazelcastException that is thrown when the system won't handle more load due to
an overload.Container for configured Hazelcast properties (see
HazelcastProperty).Interface for Hazelcast Member and Client properties.
Extended
RelOptCluster with Hazelcast-specific data.Utility class to access package-private Calcite internals.
Root Calcite schema.
Class which holds named Hazelcast permissions for Security Manager checks.
An exception thrown when a problem occurs while serializing/deserializing objects.
Main command class for Hazelcast operations
An exception occurred during SQL query execution.
PlatformTransactionManager implementation
for a single HazelcastInstance.BeanDefinitionParser for Type Configuration of Hazelcast Types like map, queue, topic etc.
Interface for providing Hazelcast as an XAResource
SplitBrainProtectionFunctions which implement this interface will be notified of member heartbeats.Merges data structure entries from source to destination data structure if the source entry
has more hits than the destination one.
SearchOptions hint definitionDeprecated.
since 5.0 use
PersistenceClusterDataRecoveryPolicyDeprecated.
since 5.0 use
DataPersistenceConfigDeprecated.
since 5.0 use
PersistenceConfigDeprecated.
since 5.0 because of renaming purposes.
Only available for HyperLogLog backed
CardinalityEstimator.IAtomicLong is a redundant and highly available distributed alternative to
the
AtomicLong.IAtomicReference is a redundant and highly available distributed alternative
to the
AtomicReference.This
In addition to the standard set of JCache methods defined in the JSR 107 specification, Hazelcast provides additional operations to support a broader range of programing styles.
ICache interface is the Cache extension offered by
Hazelcast JCache.In addition to the standard set of JCache methods defined in the JSR 107 specification, Hazelcast provides additional operations to support a broader range of programing styles.
ICacheManager is the entry point to access JSR-107 (JCache) caches via HazelcastInstance interface.This Failure Detector may be configured in addition to one of Deadline and Phi Accrual Failure Detectors.
It operates at Layer 3 of the OSI protocol, and provides much quicker and more deterministic detection of hardware
and other lower level events.
It operates at Layer 3 of the OSI protocol, and provides much quicker and more deterministic detection of hardware
and other lower level events.
Concurrent, distributed, partitioned, listenable collection.
ICountDownLatch is a backed-up distributed alternative to the
java.util.concurrent.CountDownLatch.ICredentialsFactory is used to create
Credentials objects to be used during node authentication before connection is
accepted by the master node.IdentifiedDataSerializable is an extension to
DataSerializable to avoid reflection during de-serialization.This interface represents identity configuration in security realms or client security configurations.
Distributed implementation of
ExecutorService.Represents a function that accepts one argument and produces a result.
Concurrent, distributed implementation of
List.The Hazelcast logging interface.
Concurrent, distributed, observable and queryable map.
Map events common contract.
A subset of
Queue<Object> API restricted to the consumer side,
with additional support for bulk draining operations.A marker interface for exceptions to denote that execution status of an invocation is not known
IndeterminateOperationStateException is thrown when result of an invocation becomes indecisive.
Configuration of an index.
Type of the index.
An event that is sent when a
InitialMembershipListener registers itself on a Cluster.The InitialMembershipListener is a
MembershipListener that first receives an
InitialMembershipEvent when it is registered so it immediately knows which members are available.Storage format type of values stored in cluster
Creates a
Config loaded from an in-memory Hazelcast XML String.Creates a
Config loaded from an in-memory Hazelcast YAML String.Deprecated.
since 5.0, use
JetConfig instead.TODO: Object Permission
Configures tracking of a running Hazelcast instance.
The mode in which this instance is running.
Product name for the Hazelcast instance
Enumeration of instance properties provided to the format pattern for
output.
Configures Module Integrity Checker.
Contains the configuration for Interfaces.
Function that computes the wait time necessary for each subsequent retry
attempt.
A InvalidConfigurationException is thrown when an Hazelcast faces
an invalid configuration.
IPermissionPolicy is used to determine any
Subject's
permissions to perform a security sensitive Hazelcast operation.Concurrent, blocking, distributed, observable queue.
Distributed & durable implementation similar to, but not directly
inherited
ScheduledExecutorService.A delayed result-bearing action that can be cancelled.
ISemaphore is a fault-tolerant distributed alternative to the
Semaphore.Concurrent, distributed implementation of
SetEvent for a collection item.
Type of item events.
Contains the configuration for an Item Listener.
A heterogeneous map from
Tag<E> to E, where E
can be different for each tag.Hazelcast provides distribution mechanism for publishing messages that are
delivered to multiple subscribers, which is also known as a publish/subscribe
(pub/sub) messaging model.
This
AuthenticationConfig implementation is a imple holder for login module configurations.Java KeyStore Secure Store configuration.
Configuration for Serialization Filters and Reflection Filters.
This class defines property keys that can be passed to JDBC connector.
See
Sinks.jdbcBuilder().Deprecated.
After 5.0 Jet was merged into core Hazelcast product.
Assert methods that throw exceptions similar to those thrown by JUnit.
Bean definition parser for
JetService.Deprecated.
since 5.0
Use
ICacheManager instead.Configuration object for a Jet instance.
Hazelcast serializer hooks for the classes in the
com.hazelcast.jet.config package.A Java Service Provider hook for Hazelcast's Identified Data Serializable
mechanism.
Base Jet exception.
Deprecated.
After 5.0 Jet was merged into core Hazelcast product.
Selects the members on which a specific job will run.
Jet is a component of Hazelcast to execute streaming or batch
computations.
Utility class with methods that create several useful Spring Bean
service factories and transform functions.Thrown when a named job is submitted while there is an active job
with the same name.
An interface that can be implemented to provide custom class loader for Jet
job.
Contains the configuration specific to one Hazelcast Jet job.
Some constants for the
JobConfig.getArgument(String) method.An immutable collection of job-specific metrics, pairs of metric names
and sets of associated
Measurements.Thrown when a job could not be found on the master node
A handle to an exported state snapshot created using
Job.exportSnapshot(String).Represents current status of the job from the perspective of the job coordinator.
Holds information about a job's state (status) transition,
reason for the transition, and whether it is user-initiated.
Invoked upon job status change.
Description of the cause that has led to the job being suspended.
Specifies how to join an enriching stream to the primary stream in a
hash-join operation.Contains the multiple different join configuration.
When passed to an IMap/ICache Event Journal source, specifies which
event to start from.
FileFormat for the JSON Lines files.Util class to parse JSON formatted input to various object types or
convert objects to JSON strings.
Contains factory methods to create a Kafka Connect source.
DataConnection implementation for Kafka.Static utility class with factories of Apache Kafka source and sink
processors.
Contains factory methods for Apache Kafka sinks.
A builder for Kafka sink.
Contains factory methods for Apache Kafka sources.
Typed authentication configuration for Kerberos tickets verification.
This class configures the Kerberos identity.
Holds the result of a group-and-aggregate operation performed over a
time window.
Represents the function you pass to windowing processors
such as
aggregateToSlidingWindowP()
and aggregateToSessionWindowP() as
mapToOutputFn.Contains factory methods for creating Amazon Kinesis Data Streams
(KDS) sinks.
Fluent builder for constructing the Kinesis sink and setting its
configuration parameters.
Contains factory methods for creating Amazon Kinesis Data Streams
(KDS) sources.
Fluent builder for constructing the Kinesis source and setting
its configuration parameters.
Configuration for the Kubernetes Discovery Strategy.
Configuration class of the Hazelcast Discovery Plugin for Kubernetes.
Merges data structure entries from source to destination data structure if the source entry
has been accessed more recently than the destination entry.
Merges data structure entries from source to destination data structure if the source entry
was updated more frequently than the destination entry.
Typed authentication configuration for
BasicLdapLoginModule and LdapLoginModule.Enum for LDAP role mapping modes.
Search scope types for LDAP queries.
A
CPSubsystemException which is thrown when
an appended but not-committed entry is truncated by the new leader.Event importance levels.
Lifecycle events are fired when the HazelcastInstance state changes.
Lifecycle states
Listener object for listening to lifecycle events of the Hazelcast instance
LifecycleService allows you to shutdown, terminate, and listen to
LifecycleEvents
on HazelcastInstance.Reads a line of input.
FileFormat for text files where each line is a String
data item.Maintains the components needed to compute the linear regression on a
set of
(long, long) pairs.Contains the configuration for an
IList.Contains the configuration for an
EventListener.LoadBalancer allows you to send operations to one of a number of endpoints (members).Local collections statistics to be used by
MemberState implementations.Local Device configuration for the Tiered-Store.
Local executor service statistics.
Provides local statistics for an index to be used by
MemberState
implementations.Local List statistics to be used by
MemberState implementations.Local map statistics to be used by
MemberState implementations.An exception provided to
MemberLeftException as a cause when the local member is resetting itselfLocal multi map statistics to be used by
MemberState implementations.Local queue statistics to be used by
MemberState implementations.Local replicated map statistics to be used by
MemberState
implementations.Local statistics related to partition data replication.
Local Set statistics to be used by
MemberState implementations.Local topic statistics to be used by
MemberState implementations.Thrown when the current lock holder could not acquired the lock reentrantly
because the configured lock acquire limit is reached.
Determines if the object implementing this interface is locked or not.
Thrown when an endpoint (either a Hazelcast server or a client) interacts
with a
FencedLock instance after its CP session is closed
in the underlying CP group and its lock ownership is cancelled.Logging to Log4j 2.x.
Provides static utilities to access the global shared logging machinery.
This JAAS
Callback is used to retrieve a LoggingService from the current member.Configuration for Login Module
Usage of Login Module
Mutable container of a
long value.Mutable container of a
long and a double value.Mutable container of two
long values.Implements the
TestSources.longStream(long, long) source.Container managed context, such as Spring, Guice and etc.
TransactionalTaskContext proxying implementation to make the one created by HazelcastTransactionManager
available to actual business logic.Contains the configuration for Hazelcast Management Center.
Hazelcast Permission type used in client protocol actions intended for Management Center operations.
Invoked after all entries are removed by
IMap.clear().Contains the configuration for an
IMap.Used for map-wide events like
EntryEventType.EVICT_ALL
and EntryEventType.CLEAR_ALL.Invoked after all entries are evicted by
IMap.evictAll().MapInterceptor is used to intercept changes to the map, allowing access to
the values before and after adding them to the map.
A marker interface which is used to get
notified upon a map or an entry event.
Hazelcast distributed map implementation is an in-memory data store, but
it can be backed by any type of data store such as RDBMS, OODBMS, or simply
a file-based data store.
Provides Lifecycle support for the implementing MapLoader class.
Used for providing information about the lost partition for a map
Invoked when owner and all backups of a partition is lost for a specific map.
Configuration for MapPartitionLostListener
Builder for a map that is used as sink.
Parameters for using a map as a sink with an EntryProcessor
Hazelcast distributed map implementation is an in-memory data store, but
it can be backed by any type of data store such as RDBMS, OODBMS, NOSQL,
or simply a file-based data store.
Adapter for MapStore.
Contains the configuration for a Map Store.
Initial load module
Factory for MapLoader or MapStore instances, specifiable in MapStoreConfig.
Hamcrest is great, but AssertJ is even better.
This
ConfigPatternMatcher supports a simplified wildcard matching.Maximum Size Policy
Immutable data class containing information about one metric measurement,
consisting of:
metric value
metric timestamp, generated when the metric was gathered
metric descriptor (set of tag name-value pairs)
Static utility class for creating various
Measurement filtering
predicates.Cluster member interface.
IMPORTANT
This interface is not intended to provide addresses of other cluster members with
which the hazelcast instance will form a cluster.
Configuration for a custom
MemberAddressProvider strategy.Contains configuration for attribute of member.
ConfigRecognizer implementation that recognizes Hazelcast
member declarative configurations based on an extensible set of
built-in ConfigRecognizer implementations.A collection of members to which a single partition replica can be assigned.
Contains the configuration for a single member group.
A
ExecutionException thrown when a member left during an invocation or execution.Implementations of this interface select members
that are capable of executing a special kind of task.
The
The
MemberSelector.select(Member) method is called for every available
member in the cluster and it is up to the implementation to decide
if the member is going to be used or not.A utility class to get
MemberSelector instances.Adapter for MembershipListener.
Membership event fired when a new member is added to the cluster and/or when a member leaves the cluster
and similar methods.
Cluster membership listener.
Member Socket Interceptor can be registered via
see
SocketInterceptorConfig
Warning: a MemberSocketInterceptor provides access to the socket and will bypass
any TLS encryption.Determines the Hazelcast codebase version in terms of major.minor.patch version.
This class allows to enable MEMCACHE text protocol support in Hazelcast.
Deprecated.
Since 5.1,
Capacity should be used instead.Memory tier configuration of Tiered-Store.
MemoryUnit represents memory size at a given unit of
granularity and provides utility methods to convert across units.
Configuration for
SplitBrainMergePolicy.Represents a read-only view of memory costs for the merging process after a split-brain.
Represents a read-only view of a creation time for the merging process after a split-brain.
Represents a read-only view of a data structure key/value-pair for the merging process after a split-brain.
Represents a read-only view of an expiration time for the merging process after a split-brain.
Represents a read-only view access hits for the merging process after a split-brain.
Represents a read-only view of a last access time for the merging process after a split-brain.
Represents a read-only view of a last stored time for the merging process after a split-brain.
Represents a read-only view of a last update time for the merging process after a split-brain.
Represents a read-only view of a MaxIdle for the merging process after a split-brain.
Represents a read-only view of a TTL for the merging process after a split-brain.
Represents a read-only view of a data structure value for the merging process after a split-brain.
Represents a read-only view of a version for the merging process after a split-brain.
Marker interface representing a read-only view of a data structure
for the merging process after a split-brain.
Configuration for a merkle tree.
Message for
ITopic.Message listener for
ITopic.Hazelcast may process objects of supported types ahead of time to
create additional metadata about them.
Vector similarity metrics: These are utilized in search algorithms
to retrieve the top K most similar vectors to a target vector.
Handler for manipulating one user-defined metric.
Each metric provided by Jet has a specific name which conceptually
identifies what it's being used to measure.
Utility class for obtaining handlers to user-defined metrics.
Member-side metrics collection configuration.
A Java Service Provider hook for Hazelcast's Identified Data Serializable
mechanism.
JMX related metrics configuration.
Management Center related metrics configuration.
Metric descriptors are formed from a comma separated list of
tag_name=tag_value pairs.MigrationListener provides the ability to listen to
partition migration process and events.
MigrationState shows statistical information about the migration,
such as; migration start time, number of planned replica migrations,
number of completed replica migrations, total elapsed migration time etc.
Creates a MongoDB DataConnection.
Contains factory methods for MongoDB sinks.
Top-level class for MongoDB custom source builders.
Contains factory methods for MongoDB sources.
Contains the configuration for the multicast discovery mechanism.
The multicast
DiscoveryStrategy.Factory class which returns
MulticastDiscoveryStrategy to Discovery SPIDefines the name and default value for the Multicast Discovery Strategy.
MultiExecutionCallback provides notification for when an execution is completed on each member
that a task is submitted to.
A specialized map whose keys can be associated with multiple values.
Configuration for MultiMap.
Type of value collection
Mutable container of an object reference.
Exception that indicates that the state found on this replica disallows
mutation.
Contains factory methods for creating change data capture sources
based on MySQL databases.
Builder for configuring a CDC source that streams change data
from a MySQL database to Hazelcast Jet.
Interface for hazelcast data structures with name
The
NamedTask interface should be implemented by any task that needs to have an identification and enhanced
atomicity upon scheduling the task.Marker for interfaces that can be implemented by users and executed on clusters via User Code Deployment.
Configures native memory region.
Type of memory allocator:
STANDARD: allocate/free memory using default OS memory manager
POOLED: manage memory blocks in pool
Thrown when Hazelcast cannot allocate required native memory.
Contains the configuration for a Near Cache.
Defines how to reflect local updates to the Near Cache.
Accessor for the
EvictionConfig of a NearCacheConfig to initialize the old default max size,
if no size was configured by the user.Configuration for storing and pre-loading Near Cache keys.
Near Cache statistics to be used by
MemberState implementations.Contains configuration for Network.
Exception to indicate that no credentials are possible to retrieve.
Thrown when there is no data member in the cluster to assign partitions.
The NodeFilter, if supplied, will retrieve all discovered nodes and might
apply additional filtering based on vendor provided metadata.
A
CPSubsystemException which is thrown when
a leader-only request is received by a non-leader member.Provides serialization methods for arrays of primitive types.
Provides serialization methods for arrays by extending DataOutput
Compact serializer for
ObjectId.Represents a specialization of
BiFunction where
the second argument is a long.Represents a flowing sequence of events produced by observable sinks.
Observes the events produced by an
Observable.Allows off-loading the processing unit implementing this interface to the specified or default Executor.
Enum of operation names for handling client permissions when the member is joining into the cluster.
Describes the nature of a CDC event, mainly the type of action performed
on a database record: insertion, update and deletion.
An unchecked version of
TimeoutException.Data sink for a
Processor.Handler for
OutOfMemoryError.Using this policy one can control the behavior what should to be done
when an item is about to be added to the ringbuffer, but there is
0
remaining capacity.This interface is a special Predicate which helps to get a page-by-page result of a query.
Implements a mock batch source with parallelism.
Implements a mock stream source with parallelism.
This interface is used to pass parameters of a method call to a
SecurityInterceptor.FileFormat for Parquet files.Exception to indicate that parsing CDC JSON data has failed irrecoverably.
In Hazelcast the data is split up in partitions: by default, 271 and configurable through the 'hazelcast.partition.count'
ClusterProperty.
PartitionAware means that data will be based in the same member based on the partition key
and implementing tasks will be executed on the
PartitionAware.getPartitionKey()'s owner member.A
PartitionAware key.Encapsulates the logic associated with a
DAG edge that decides
on the partition ID of an item traveling over it.Partitioner which applies the default Hazelcast partitioning strategy.
PartitionEvent is a base interface for partition related events.
With PartitionGroupConfig, you can control how primary and backup partitions are mapped to physical Members.
Type of member groups.
This class contains the definition of known Discovery SPI metadata to support automatic
generation of zone aware and node aware backup strategies.
A
PartitionGroupStrategy implementation defines a strategy
how backup groups are designed.Contains the configuration for attributes used to create
AttributePartitioningStrategyPartitioningStrategy allows keys to be located on the same member.
Contains the configuration for partitioning strategy.
The event is fired when a primary replica of the partition is lost.
PartitionLostListener provides the ability to be notified upon a
possible data loss when a partition loses a replica.
A
RetryableHazelcastException that is thrown when an operation is executed
on a partition, but that partition is currently being moved around.PartitionService allows you to query
Partitions and attach/detach MigrationListeners to listen to partition
migration events.Merges data structure entries from source to destination directly unless the merging entry is
null.Credentials type for name/password representation.Represents a penta-arity function that accepts
five arguments and produces a result.
Contains the configuration for a permission.
Type of permission
Contains the configuration for policy of permission
Utility class for security permissions.
Specifies the policy that will be respected during persistence cluster start
Configures the Persistence stores.
Service for interacting with Persistence.
Configuration class for persistent memory devices (e.g.
Configuration class for directories that persistent memories are mounted at.
The enumeration of the supported persistent memory operational modes.
Keeps the state needed to implement the
AggregateOperations.pickAny() aggregate operation.Split brain protection functions that need access to ICMP ping failure detector should implement this interface;
the instance of
PingFailureDetector used by this member's
ClusterHeartbeatManager will be provided on initialization.Models a distributed computation job using an analogy with a system of
interconnected water pipes.
The Pipelining can be used to speed up requests.
PN (Positive-Negative) CRDT counter.
Configuration for a
PNCounterDeprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Represents the range of IPv4 Ports.
Contains factory methods for creating change data capture sources
based on PostgreSQL databases.
Builder for configuring a CDC source that streams change data
from a PostgreSQL database to Hazelcast Jet.
Possible postgres snapshot modes, that does not require additional mandatory parameters to be set.
Implement this interface if you modify the value in MapStore.store(K key, V value) method.
Represents a map entry predicate.
This interface provides functionality to build a predicate.
This interface provides entry-level functionality related to building a predicate.
Contains the configuration for an
Predicate.Serializable variant of java.util.function.Predicate which declares checked exception.A utility class to create new
PredicateBuilder and Predicate instances.Contact point for special
DistributedObject's which has prefixed name.Marker for private functionality.
Builder for a
SplitBrainProtectionConfig configured with ProbabilisticSplitBrainProtectionFunction that
considers members present in the context of a split brain protection using a probabilistic,
adaptive split brain protection function.Defines what message processing guarantees are given under failure
conditions.
When Jet executes a DAG, it creates one or more instances of
Processor on each cluster member to do the work of a given vertex.Context passed to the processor in the
init() call.Factory of
ProcessorSupplier instances.Context passed to the meta-supplier at init time on the member that
received a job request from the client.
A meta-supplier that will only use the given
ProcessorSupplier
on a node with given Address or random member if address is not given.Static utility class with factory methods for Jet processors.
Factory of
Processor instances.Context passed to the supplier in the
init() call.Enables transforming object into other objects.
A utility class to create basic
Projection instances.This interface describes an extended approach of the currently available
pure property based configuration inside Hazelcast and helps implementing
an automatic and transparent way to verify configuration as well as converting
types based on provided validators and converters.
ConfigReplacer for replacing property names with property values for properties provided in
PropertyReplacer.init(Properties) method.This enum class contains basic
TypeConverter implementations to
convert strings to all common basic Java types.ProtobufSerializer<T extends com.google.protobuf.GeneratedMessageV3>
Adapts a generated
Google Protocol Buffers v3 serializer class to the Hazelcast
StreamSerializer interface.ProtobufSerializerHook<T extends com.google.protobuf.GeneratedMessageV3>
Simplifies using the Hazelcast Serializer
Hook mechanism to register a Google Protocol Buffers serializer with
the Hazelcast Jet cluster.
This class is related to SPI.
Merges data structure entries from source to destination if they don't exist in the destination data structure.
Configuration object for the Python service factory, used in a
mapUsingPython stage.Transforms which allow the user to call Python user-defined functions
from inside a Jet pipeline.
Represents a four-arity function that accepts four arguments and
produces a result.
A concurrent, queryable data structure which is used to cache results of
a continuous query executed on an
IMap.Contains configuration for
QueryCache.Contains constants for Query.
Exception class for the Query.
This exception is thrown when a query exceeds a configurable result size limit.
Contains the configuration for an
IQueue.QueueStore makes a queue backed by a central data store; such as database, disk, etc.
Configuration for the
QueueStore.Creates a new
QueueStore.Configuration for Hazelcast's implementation of the Raft consensus algorithm
A
LoadBalancer that selects a random member to route to.FileFormat for binary files where the whole file is one
byte[] item.Exception thrown when a write-behind
MapStore rejects to accept a new element.Allows notifying Hazelcast that the processing unit implementing this interface will not do any modifications.
The result of a
Ringbuffer.readManyAsync(long, int, int, com.hazelcast.core.IFunction)
operation.Security realm represents the security configuration for part of the system (e.g.
This JAAS
Callback is used to retrieve a RealmConfig from client or member configuration.This
Callback allows retrieving the current security realm name.Builder for a
SplitBrainProtectionConfig configured with RecentlyActiveSplitBrainProtectionFunction that
considers members present in the context of a split brain protection if the last received heartbeat
is within a recent window of time.Represents the top-level component of a
ChangeRecord, such as
the key or the value.This
ConfigPatternMatcher uses Java regular expressions for matching.Parser for RegionFactory.
A
MessageListener to better integrate with the reliable topic.Configuration for a reliable
ITopic.Builder providing a fluent API to build a remote map source.
An event fired when a partition replica migration completes or fails.
A ReplicatedMap is a map data structure with weak consistency
and has entries stored locally on every node of the cluster.
Thrown when
HazelcastInstance.getReplicatedMap(String) is invoked on a lite member.Contains the configuration for an
ReplicatedMapTraverses over a single item which can be set from the outside, by using
this traverser as a
Consumer<T>.Defines when and if database and collection existence will be checked.
Describes a single resource to deploy to the Jet cluster.
Represents the type of the resource to be uploaded.
A class that enables access to protected
Resources members.A HazelcastException indicating that there is some kind of system error causing a response to be send
multiple times for some operation.
This class allows controlling which parts of Hazelcast REST API will be enabled.
Exception to throw from job-executing methods to indicate a failure that can
be resolved by restarting the job.
Exception to indicate any issues while executing a REST call.
This class allows controlling the Hazelcast REST API feature.
Client authentication types.
Enum of REST endpoint groups.
Server socket endpoint config specialized for REST service
Allows configuring access to REST groups similar to
RestApiConfigMarker interface for exceptions to indicate that an operation can be retried.
A 'marker' exception that indicates that an operation can be retried.
A
IOException indicating that there was a IO failure, but it can be retried.Collection of factory methods for creating the most frequently used
RetryStrategies.Builder for custom retry strategies.
Description of a strategy to take when an action fails, like when
connecting to a server.
Static utility class to retry operations.
A Ringbuffer is a data structure where the content is stored in a ring-like
structure.
Contains the configuration for the
Ringbuffer.A ringbuffer implementation holding data involved in split-brain healing.
Read-only iterator over items in a provided
RingbufferMergeData.Ringbuffer store makes a ring buffer backed by a central data store; such as database, disk, etc.
Configuration for the
RingbufferStore.Creates a new
RingbufferStore.A
LoadBalancer implementation that relies on using round robin
to a next member to send a request to.An unchecked version of
InterruptedException.Contains factory methods for creating AWS S3 sinks.
Contains factory methods for creating AWS S3 sources.
Configuration options for the
IScheduledExecutorService.Capacity policy options
Resource handler pointing to a
IScheduledFuture.Statistics and timing info for a
IScheduledFuture accessible through IScheduledFuture.getStats()Vector search options
Search options builder
Single vector search result
A secure callable that runs in a sandbox.
Abstract Secure Store configuration class.
Contains configuration for Security
SecurityContext is responsible for managing lifecycle of security object such as
ICredentialsFactory, IPermissionPolicy etc, to creating LoginContextes
for member and client authentications and checking permissions for client operations.This JAAS
Callback is used to retrieve a SecurityContext from the current member.This interface allows to intercept requests which were produced by an API call like map.put, queue.offer...
This class is used to configure
SecurityInterceptorProvides necessary methods to initiate security related config changes.
Contains configuration options for CP
ISemaphoreContains the serialization configuration of
HazelcastInstance.Base interface of custom serialization interfaces
Contains the serialization configuration for a particular class.
This interface is used to automatically register serializers from external
Hazelcast or user modules.
Endpoint configuration that defines a listening side (server)
Configuration for a single service.
Utility class with methods that create several useful
service factories.A holder of functions needed to create and destroy a service object used in
pipeline transforms such as
stage.mapUsingService().A
HazelcastException that indicates that a requested service is not exist.Represents the definition of a session window.
Contains the configuration for an
ISet.Marker interface for exceptions.
Typed authentication configuration for
SimplePropertiesLoginModule.Helper immutable object representing user attributes (i.e.
Simple immutable implementation of the
DiscoveryNode interface for convenience
when implementing a DiscoveryStrategy.A simple event with a timestamp and a sequence number.
Simple immutable implementation of
PropertyDefinition for convenience of implementors.Simple implementation of
Credentials using a raw byte array token.A simulated load test.
A data sink in a Jet pipeline.
Static utility class with factories of sink processors (the terminators
of the DAG data flow).
Contains factory methods for various types of pipeline sinks.
A pipeline stage that doesn't allow any downstream stages to be attached
to it.
Represents the definition of a sliding window.
Contains parameters that define a sliding/tumbling window over which Jet
will apply an aggregate function.
An interface that provides the ability to intercept the creation of sockets.
Contains the configuration for interceptor socket.
TCP Socket options
Top-level class for Jet custom source builders.
The buffer object that the
fillBufferFn gets on each call.The buffer object that the
fillBufferFn gets on each call.Static utility class with factories of source processors (the DAG
entry points).
Contains factory methods for various types of pipeline sources.
Policy for merging data structure values
after a split-brain has been healed.
A provider for
SplitBrainMergePolicy instances.Collection of interfaces which define the provided merge types for each data structure.
Provided merge types of
IAtomicLong.Provided merge types of
IAtomicReference.Provided merge types of
ICache.Provided merge types of
CardinalityEstimator.Provided merge types of
IMap.Provided merge types of
MultiMap.Provided merge types of
IQueue.Provided merge types of
ReplicatedMap.Provided merge types of
Ringbuffer.Provided merge types of
IScheduledExecutorService.SplitBrainProtection provides access to the current status of a split brain protection.Configuration for cluster split brain protection, a means to protect consistency of data from network
partitions.
Commons for split brain protection config builders.
An Event that is send when a
SplitBrainProtection changes.An exception thrown when the cluster size is below the defined threshold.
A function that can be used to conclude whether the minimum cluster size property is satisfied?
The split brain protection function is consulted:
When a cluster membership change occurs (member added or removed) Whenever a hearbeat is received from a member, in case the
When a cluster membership change occurs (member added or removed) Whenever a hearbeat is received from a member, in case the
SplitBrainProtectionFunction also
implements HeartbeatAware
A SplitBrainProtectionFunction that implements HeartbeatAware will be also notified of heartbeats.Listener to get notified when a split brain protection state is changed.
Configuration class for
SplitBrainProtectionListenerRepresents a cluster split brain protection type
Split brain protection service can be used to trigger cluster split brain protections at any time.
Annotates a class for injection of Spring dependencies.
Spring utility class for connecting
HazelcastCachingProvider interface and Hazelcast instance.ManagedContext implementation for Hazelcast.SQL column metadata.
SQL column type.
SQL service configuration.
The expected statement result type.
SQL query result.
SQL row.
SQL row metadata.
A service to execute SQL statements.
Definition of an SQL statement.
A class that allows to override the
SqlValidatorImplBridge.deriveTypeImpl(SqlValidatorScope, SqlNode) method, which is package-private
in the parent class.SSL configuration.
The basic element of a Jet
pipeline, represents
a computation step.Represents an intermediate step in the construction of a pipeline stage
that performs a windowed group-and-aggregate operation.
Represents an intermediate step in the construction of a pipeline stage
that performs a windowed aggregate operation.
A
CPSubsystemException which is thrown when a Raft leader node
appends an entry to its local Raft log, but demotes to the follower role
before learning the commit status of the entry.An
RuntimeException that is thrown when accessing an item in the Ringbuffer using a sequence that is smaller
than the current head sequence and that the ringbuffer store is disabled.Exception thrown by the
IScheduledFuture during any operation on a stale (=previously destroyed) task.An
RuntimeException that is thrown when retrieving the result of a task via DurableExecutorService if the
result of the task is overwritten.An interface to provide means for saving & loading state for
Runnable and Callable
tasks scheduled with an IScheduledExecutorService.The credentials factory implementation which just takes credentials in a constructor and provides it for every
StaticCredentialsFactory.newCredentials() call.The StaticLB is a
LoadBalancer that always returns the same member.Offers a step-by-step fluent API to build a hash-join pipeline stage.
A base class for custom serialization.
An infinite source of data for a Jet pipeline.
A source stage in a distributed computation
pipeline
that will observe an unbounded amount of data (i.e., an event stream).A stage in a distributed computation
pipeline that will
observe an unbounded amount of data (i.e., an event stream).An intermediate step while constructing a pipeline transform that
involves a grouping key, such as windowed group-and-aggregate.
Serializable variant of java.util.function.Supplier
which declares checked exception.Deprecated.
since 4.2
A tag object useful as a key in heterogeneous maps.
Thrown when a client invocation is failed because related target is disconnected and
whether the invocation is run or not, is indeterminate
A
RetryableHazelcastException that indicates operation was sent to a
machine that isn't member of the cluster.Exception that indicates that the receiver of a CRDT operation is not
a CRDT replica.
Contains the configuration for the Tcp/Ip join mechanism.
Interface to be implemented by classes which can be queried for requirement
of a tenant context.
Hooks for multi-tenancy for application servers.
Similar to the
Closeable interface, except the TenantControl.Closeable.close()
method does not throw a IOException.A
TenantControlFactory supplies TenantControl objects when
Hazelcast service attaches the tenant control to a distributed object.Inbox implementation suitable to be used in tests.Outbox implementation suitable to be used in tests.Processor.Context implementation suitable to be used in tests.ProcessorMetaSupplier.Context implementation suitable to be used
in tests.Implementation of
ProcessorSupplier.Context suitable to be used
in tests.Contains factory methods for various mock sources which can be used for
pipeline testing and development.
A utility to test processors.
Describes the current test mode.
FileFormat for text files where the whole file is one
String data item.Tiered-Store configuration.
Mutable wrapper around an item that adds a timestamp.
Enumerates the two possible kinds of timestamp: event timestamp and
frame timestamp.
Typed authentication configuration for the
X509CertificateLoginModule.Serializable variant of java.util.function.ToDoubleFunction which declares checked exception.Serializable variant of java.util.function.ToIntFunction which declares checked exception.Credentials type for custom authentication (token based).Possible token encodings.
Simple token identity configuration.
Serializable variant of java.util.function.ToLongFunction which declares checked exception.Contains the configuration for a
ITopic.A
HazelcastException thrown when a publisher wants to write to a topic, but there is not sufficient storage
to deal with the event.A policy to deal with an overloaded topic; so topic where there is no
place to store new messages.
Contains the configuration for all Kafka topics that will be consumed by the
Kafka source processor.
Contains the configuration for a single Kafka topic.
Thrown when a topology change causes a job to abort.
A function that accepts a JDBC connection to the database, the total
parallelism and processor index as arguments and produces a result set.
Hazelcast TPC is the next generation of Hazelcast built with thread
per core architecture.
Socket configuration for TPC.
Transactional implementation of
IList.Transactional implementation of
BaseMap.Transactional implementation of
BaseMultiMap.Marker interface for all transactional distributed objects.
Transactional implementation of
BaseQueue.Transactional implementation of
ISet.Contains the logic that is going to be executed within a transaction.
Provides a context to access transactional data-structures, like the
TransactionalMap.Provides a context to perform transactional operations: beginning/committing transactions, but also retrieving
transactional data-structures like the
TransactionalMap.A
HazelcastException that is thrown when something goes wrong
while dealing with transactions and transactional data-structures.A
HazelcastException thrown when an a transactional operation is executed without an active transaction.Contains the configuration for a Hazelcast transaction.
The type of transaction.
Thrown when a transaction has timed out.
Traverses a potentially infinite sequence of non-
null items.Represents a three-arity function that accepts three arguments and
produces a result.
Represents a predicate which accepts three arguments.
Interface defining methods used to configure trusted interfaces (source IP addresses).
An immutable 2-tuple (pair) of statically typed fields.
An immutable 3-tuple (triple) of statically typed fields.
An immutable 4-tuple of statically typed fields.
An immutable 5-tuple of statically typed fields.
Implementations of this interface define a certain type conversion.
This interface allows deserialization of a binary data with a provided class type.
This interface adds the possibility for the class to act as if it is another class when being deserialized using
DataSerializable
This interface allows deserialization of a binary data with a provided class type.
This exception is thrown when an exception that is coming from server is not recognized by the protocol and
it can not be constructed by the client via reflection.
Measurement unit of user-defined metrics (see
Metric).A
Config which is loaded using some url pointing to a Hazelcast XML file.A
Config which is loaded using some url pointing to a Hazelcast YAML file.Deprecated, for removal: This API element is subject to removal in a future version.
since 5.4, "User Code Deployment" is replaced by the "User Code Namespaces" feature
Controls caching of classes loaded from remote members
Controls how to react to receiving a classloading request from a remote member
Deprecated, for removal: This API element is subject to removal in a future version.
since 5.4, "User Code Deployment" is replaced by the "User Code Namespaces" feature
An interface to mark implementing configs as "Namespace aware", meaning they should
support the definition of a
User Code Namespace string which represents the
User Code Namespace to associate with all operations pertaining to this config.Contains the configuration for a specific User Code Namespace, defining its identifier
(name) as well as the definitions for resources it provides.
Serves as the configuration container for all aspects of Namespaces, used in User Code Deployment.
Simple implementation of
PasswordCredentials using
name and password as security attributes.Simple username/password identity configuration.
Miscellaneous utility methods useful in DAG building logic.
This exception is thrown from
ValueValidator
implementations whenever the validation has not succeed for any reason.Enables notifying about values extracted in a
ValueExtractorEnables collecting values extracted in a
ValueExtractorCommon superclass for all extractors that enable the user to define custom attributes and extract their values.
Enables reading the value of the attribute specified by the path
Exception thrown if there is any checked or unchecked exception caught in the value reading in
ValueReaderThis interface defines a certain validation logic implementation
to test if a given value is expected to be correct or not.
HashiCorp Vault Secure Store configuration.
Configuration object for a vector collection.
A
VectorDocument includes a user-supplied V value and the associated VectorValues
that represent the document.Configuration for a vector index.
A
VectorValues instance contains the vectors that describe a VectorDocument.Provides a mapping from index name to vector, supplying vectors for a
VectorCollection
with multiple indexes defined.Represents values of a single vector.
A generic version to be used with
VersionAware classes.An instance which supports versioning.
Deprecated, for removal: This API element is subject to removal in a future version.
Portable Serialization has been deprecated.
Represents a unit of data processing in a Jet computation job.
Determines acknowledge waiting type of wan replication operation invocation.
Configuration object for the built-in WAN publisher (available in
Hazelcast Enterprise).
Interface to be implemented by custom WAN event consumers.
Config for processing WAN events received from a target cluster.
Configuration object for a custom WAN publisher.
Interface for all WAN replication messages
Counters for WAN events for a single distributed object type (map or
cache).
Counters for WAN events for a single map or cache.
The type of the WAN event, signifies the type of the mutation that occurred
that caused the WAN event.
Interface for WAN publisher migration related events.
An instance which is used in WAN and supports versioning.
This interface offers the implementation of different kinds of replication
techniques like TCP, UDP or maybe even an JMS based service.
Defines the state in which a WAN publisher can be in if it is not shutting
down.
Determines the behavior of WAN replication
impl.
A
HazelcastException that
is thrown when the wan replication queues are full
This exception is only thrown when WAN is configured with
WanQueueFullBehavior.THROW_EXCEPTIONConfiguration for WAN replication.
Configuration for a WAN target replication reference.
Configuration object for the WAN sync mechanism.
Watermark is an item occasionally inserted into a disordered
(sub)stream of timestamped items.
This object tracks and determines the current
Watermark given the
event timestamps as they occur for a single input stream.This
ConfigPatternMatcher supports a simplified wildcard matching.Offers a step-by-step fluent API to build a pipeline stage that
performs a windowed co-aggregation of the data from several input
stages.
Offers a step-by-step fluent API to build a pipeline stage that
performs a windowed co-aggregation of the data from several input stages.
The definition of the window for a windowed aggregation operation.
Offers a step-by-step API to build a pipeline stage that performs a
windowed co-grouping and aggregation of the data from several input
stages.
Offers a step-by-step API to build a pipeline stage that performs a
windowed co-grouping and aggregation of the data from several input
stages.
Holds the result of an aggregate operation performed over a time
window.
Defines allowed operations.
A
RetryableHazelcastException indicating that an operation is executed on
a wrong member.Loads the
ClientConfig using XML.Loads the
ClientFailoverConfig using XML.A XML
ConfigBuilder implementation.Loads the
ClientConfig using YAML.Loads the
ClientFailoverConfig using YAML.A YAML
ConfigBuilder implementation.