All Classes and Interfaces

Class
Description
Configuration base for config types with a factory class and its properties.
Base class for CacheConfig
Common 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 approaches
Offers 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 execution
FileFormat 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 SPI
Configuration for the Azure Discovery Strategy.
Azure implementation of DiscoveryStrategy
Factory class which returns AzureDiscoveryStrategy to Discovery SPI
An 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 CompleteConfiguration
Control caching of de-serialized values.
Entry info for cache record.
Hazelcast JCache implementation's internal event types.
ICache specific EvictionPolicyComparator for comparing CacheEntryViews to be evicted.
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 MemoryUnit.
CardinalityEstimator 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 CardinalityEstimator
 
Contains 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.
A configuration of a data connection that can be used: to create a source or sink in a Jet Pipeline, as a data connection for MapStore and MapLoader, to create an SQL mapping.
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 API
The 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.
Represents an edge between two vertices in a DAG.
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 RestClientBuilder
Builder for Elasticsearch Sink
Provides factory methods for Elasticsearch sinks.
Builder for Elasticsearch source which reads data from Elasticsearch and converts SearchHits using provided mapToItemFn
Provides 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 EntryListener
Invoked 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 FencedLock
Defines the name, type and index of a field.
FieldKind for Compact and Portable formats.
Field Type for Portable format to be used with ClassDefinition.getFieldType(String) API
Describes 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 mapOutputFn
Contains 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.
The common aspect of batch and stream pipeline stages, defining those operations that apply to both.
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.
A generic object interface that is returned to the user when the domain class can not be created from any of the distributed Hazelcast data structures like IMap, IQueue etc.
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 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.
Deprecated.
Deprecated.
since 5.0 use DataPersistenceConfig
Deprecated.
since 5.0 use PersistenceConfig
Deprecated.
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 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.
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 Set
Event for a collection item.
Type of item events.
Item listener for IQueue, ISet and IList
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.
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.
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.
A handle to Jet computation job created by submitting a DAG or Pipeline to the cluster.
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 itself
Local 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().
IMap specific EvictionPolicyComparator for comparing EntryViews to be evicted.
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 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.
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 SPI
Defines 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.
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 AttributePartitioningStrategy
PartitioningStrategy 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.
A Predicate that restricts the execution of a Predicate to specific partitions.
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 PNCounter
 
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.
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.
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 ReplicatedMap
 
Traverses 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 RestApiConfig
Marker 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()
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 SecurityInterceptor
 
Provides necessary methods to initiate security related config changes.
Contains configuration options for CP ISemaphore
 
Contains 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 collections (ISet and IList).
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 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 SplitBrainProtectionListener
Represents 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.
A helper class with utilities to act upon Runnable and/or Callable tasks.
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.
Utility class with several Traversers useful in Processor implementations.
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 ValueExtractor
Enables collecting values extracted in a ValueExtractor
Common 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 ValueReader
This 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.
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_EXCEPTION
Configuration 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.