Uses of Class
com.hazelcast.spi.annotation.Beta

Packages that use Beta

Package	Description
com.hazelcast.core	Provides core API interfaces/classes.
com.hazelcast.mapreduce	This package contains the MapReduce API definition for Hazelcast. All map reduce operations running in a distributed manner inside the active Hazelcast cluster.
com.hazelcast.mapreduce.aggregation	This package contains the aggregation API and the convenience helper classes to retrieve predefined aggregation implementations.
com.hazelcast.transaction.impl	Provides implementation for Hazelcast transaction support.

Packages with annotations of type Beta

Package	Description
com.hazelcast.mapreduce	This package contains the MapReduce API definition for Hazelcast. All map reduce operations running in a distributed manner inside the active Hazelcast cluster.

Uses of Beta in com.hazelcast.core

Classes in com.hazelcast.core with annotations of type Beta

Modifier and Type	Interface and Description
interface	AsyncAtomicLong A IAtomicLong that exposes its operations using a ICompletableFuture so it can be used in the reactive programming model approach.
interface	AsyncAtomicReference<E> A IAtomicReference that exposes its operations using a ICompletableFuture so it can be used in the reactive programming model approach.
interface	ICompletableFuture<V> A Future where one can asynchronously listen on completion.
interface	ReplicatedMap<K,V> A ReplicatedMap is a map like data structure with non-strong consistency (so-called eventually consistent) and values are locally stored on every node of the cluster.

Uses of Beta in com.hazelcast.mapreduce

Classes in com.hazelcast.mapreduce with annotations of type Beta

Modifier and Type	Interface and Description
interface	Collator<ValueIn,ValueOut> This interface can be implemented to define a Collator which is executed after calculation of the MapReduce algorithm on remote cluster nodes but before returning the final result. Collator can for example be used to sum up a final value.
class	Combiner<ValueIn,ValueOut> The abstract Combiner class is used to build combiners for the Job. Those Combiners are distributed inside of the cluster and are running alongside the Mapper implementations in the same node. Combiners are called in a threadsafe way so internal locking is not required.
interface	CombinerFactory<KeyIn,ValueIn,ValueOut> A CombinerFactory implementation is used to build Combiner instances per key. An implementation needs to be serializable by Hazelcast since it is distributed together with the Mapper implementation to run alongside.
interface	Context<K,V> The Context interface is used for emitting keys and values to the intermediate working space of the MapReduce algorithm.
interface	Job<KeyIn,ValueIn> This interface describes a mapreduce Job that is build by JobTracker.newJob(KeyValueSource). It is used to execute mappings and calculations on the different cluster nodes and reduce or collate these mapped values to results.
interface	JobCompletableFuture<V> This is a special version of ICompletableFuture to return the assigned job id of the submit operation.
interface	JobPartitionState An implementation of this interface contains current information about the status of an process piece while operation is executing.
interface	JobProcessInformation This interface holds basic information about a running map reduce job like state of the different partitions and the number of currently processed records. The number of processed records is not a real time value but updated on regular base (after 1000 processed elements per node).
interface	JobTracker The JobTracker interface is used to create instances of Jobs depending on the given data structure / data source.
interface	KeyPredicate<Key> This interface is used to pre evaluate keys before spreading the MapReduce task to the cluster.
class	KeyValueSource<K,V> The abstract KeyValueSource class is used to implement custom data sources for mapreduce algorithms. Default shipped implementations contains KeyValueSources for Hazelcast data structures like IMap and MultiMap.
interface	LifecycleMapper<KeyIn,ValueIn,KeyOut,ValueOut> The LifecycleMapper interface is a more sophisticated version of Mapper normally used for complexer algorithms with a need of initialization and finalization.
class	LifecycleMapperAdapter<KeyIn,ValueIn,KeyOut,ValueOut> The abstract LifecycleMapperAdapter superclass is used to ease building mappers for the Job.
interface	Mapper<KeyIn,ValueIn,KeyOut,ValueOut> The interface Mapper is used to build mappers for the Job.
interface	MappingJob<EntryKey,KeyIn,ValueIn> This interface describes a mapping mapreduce Job. For further information Job.
interface	PartitionIdAware This interface can be used to mark implementation being aware of the data partition it is currently working on.
class	Reducer<ValueIn,ValueOut> The abstract Reducer class is used to build reducers for the Job. Reducers may be distributed inside of the cluster but there is always only one Reducer per key.
interface	ReducerFactory<KeyIn,ValueIn,ValueOut> A ReducerFactory implementation is used to build Reducer instances per key. An implementation needs to be serializable by Hazelcast since it might be distributed inside the cluster to do parallel calculations of reducing step.
interface	ReducingJob<EntryKey,KeyIn,ValueIn> This interface describes a reducing mapreduce Job. For further information Job.
interface	ReducingSubmittableJob<EntryKey,KeyIn,ValueIn> This interface describes a submittable mapreduce Job. For further information Job.
class	TopologyChangedException This exception is thrown when a topology change happens during the execution of a map reduce job and the TopologyChangedStrategy is set to TopologyChangedStrategy.CANCEL_RUNNING_OPERATION.
class	TopologyChangedStrategy This enum class is used to define how a map reduce job behaves if the job owner recognizes a topology changed event. When members are leaving the cluster it might happen to loose processed data chunks that were already send to the reducers on the leaving node. In addition to that on any topology change there is a redistribution of the member assigned partitions which means that a map job might have a problem to finish it's currently processed partition. The default behavior is immediately cancelling the running task and throwing an TopologyChangedException but it is possible to submit the same job configuration again if JobTracker.getTrackableJob(String) returns null for the requested job id.
interface	TrackableJob<V> This interface describes a trackable job.

Uses of Beta in com.hazelcast.mapreduce.aggregation

Classes in com.hazelcast.mapreduce.aggregation with annotations of type Beta

Modifier and Type	Interface and Description
interface	Aggregation<Key,Supplied,Result> The Aggregation interface combines multiple map-reduce operations steps to a single operation definition.
class	Aggregations This class is used to access the Hazelcast predefined set of aggregations in a type-safe way.
interface	PropertyExtractor<ValueIn,ValueOut> The PropertyExtractor interface is used in suppliers to retrieve values from input value types and extract or transform them to some other type to be used in aggregations.
class	Supplier<KeyIn,ValueIn,ValueOut> The Supplier interface is used to supply values from input data structures like IMap or MultiMap to an aggregation.

Uses of Beta in com.hazelcast.transaction.impl

Classes in com.hazelcast.transaction.impl with annotations of type Beta

Modifier and Type	Class and Description
class	XAResourceImpl