Atomix (Atomix API Reference (3.0.0))

java.lang.Object
- io.atomix.cluster.AtomixCluster
- - io.atomix.core.Atomix

All Implemented Interfaces:

BootstrapService, PrimitivesService, PrimitiveFactory, Managed<Void>
```
public class Atomix
extends AtomixCluster
implements PrimitivesService
```
Primary interface for managing Atomix clusters and operating on distributed primitives.
The Atomix class is the primary interface to all Atomix features. To construct an Atomix instance, either configure the instance with a configuration file or construct a new instance from an AtomixBuilder. Builders can be created via various builder() methods:
```
   
   Atomix atomix = Atomix.builder()
     .withMemberId("member-1")
     .withAddress("localhost:5000")
     .build();
   
 
```
Once an Atomix instance has been constructed, start the instance by calling start():
```
   
   atomix.start().join();
   
 
```
The returned CompletableFuture will be completed once the node has been bootstrapped and all services are available.
The instance can be used to access services for managing the cluster or communicating with other nodes. Additionally, it provides various methods for creating and operating on distributed primitives. Generally, the primitive methods are separated into two types. Primitive getters return multiton instances of a primitive. Primitives created via getters must be pre-configured in the Atomix instance configuration. Alternatively, primitive builders can be used to create and configure primitives in code:
```
   
   AtomicMap<String, String> map = atomix.mapBuilder("my-map")
     .withProtocol(MultiRaftProtocol.builder("raft")
       .withReadConsistency(ReadConsistency.SEQUENTIAL)
       .build())
     .build();
   
 
```
Custom primitives can be constructed by providing a custom PrimitiveType and using the primitiveBuilder(String, PrimitiveType) method:
```
   
   MyPrimitive myPrimitive = atomix.primitiveBuilder("my-primitive, MyPrimitiveType.instance())
     .withProtocol(MultiRaftProtocol.builder("raft")
       .withReadConsistency(ReadConsistency.SEQUENTIAL)
       .build())
     .build();
   
 
```

Constructor Summary

Constructors
Constructor and Description
`Atomix(ClassLoader classLoader, File... configFiles)`
`Atomix(ClassLoader classLoader, List<File> configFiles)`
`Atomix(ClassLoader classLoader, String... configFiles)`
`Atomix(File... configFiles)`
`Atomix(String... configFiles)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static AtomixBuilder`	`builder()` Returns a new Atomix builder.
`static AtomixBuilder`	`builder(AtomixConfig config)` Returns a new Atomix builder.
`static AtomixBuilder`	`builder(AtomixConfig config, ClassLoader classLoader)` Returns a new Atomix builder.
`static AtomixBuilder`	`builder(ClassLoader classLoader)` Returns a new Atomix builder.
`static AtomixBuilder`	`builder(String config)` Returns a new Atomix builder.
`static AtomixBuilder`	`builder(String configFile, ClassLoader classLoader)` Returns a new Atomix builder.
`static AtomixConfig`	`config()` Returns a new Atomix configuration.
`static AtomixConfig`	`config(ClassLoader classLoader)` Returns a new Atomix configuration.
`static AtomixConfig`	`config(ClassLoader classLoader, List<File> files)` Returns a new Atomix configuration from the given file.
`static AtomixConfig`	`config(ClassLoader classLoader, String... files)` Returns a new Atomix configuration from the given file.
`static AtomixConfig`	`config(File... configFiles)` Returns a new Atomix configuration.
`static AtomixConfig`	`config(List<File> files)` Returns a new Atomix configuration from the given file.
`static AtomixConfig`	`config(String... files)` Returns a new Atomix configuration from the given file.
`AtomicCounter`	`getAtomicCounter(String name)` Gets or creates a `AtomicCounter`.
`<K> AtomicCounterMap<K>`	`getAtomicCounterMap(String name)` Gets or creates a `AtomicCounterMap`.
`<V> AtomicDocumentTree<V>`	`getAtomicDocumentTree(String name)` Gets or creates a `AtomicDocumentTree`.
`AtomicIdGenerator`	`getAtomicIdGenerator(String name)` Gets or creates a `AtomicIdGenerator`.
`AtomicLock`	`getAtomicLock(String name)` Gets or creates a `AtomicLock`.
`<K,V> AtomicMap<K,V>`	`getAtomicMap(String name)` Gets or creates a `AtomicMap`.
`<K,V> AtomicMultimap<K,V>`	`getAtomicMultimap(String name)` Gets or creates a `AtomicMultimap`.
`<K extends Comparable<K>,V> AtomicNavigableMap<K,V>`	`getAtomicNavigableMap(String name)` Gets or creates a `AtomicNavigableMap`.
`AtomicSemaphore`	`getAtomicSemaphore(String name)` Gets or creates a `AtomicSemaphore`.
`<K extends Comparable<K>,V> AtomicSortedMap<K,V>`	`getAtomicSortedMap(String name)` Gets or creates a `AtomicSortedMap`.
`<V> AtomicValue<V>`	`getAtomicValue(String name)` Gets or creates a `AtomicValue`.
`ConfigService`	`getConfigService()` Returns the primitive configuration service.
`DistributedCounter`	`getCounter(String name)` Gets or creates a `DistributedCounter`.
`DistributedCyclicBarrier`	`getCyclicBarrier(String name)` Gets or creates a `DistributedCyclicBarrier`.
`ScheduledExecutorService`	`getExecutorService()` Returns the core Atomix executor service.
`<T> LeaderElection<T>`	`getLeaderElection(String name)` Gets or creates a `LeaderElection`.
`<T> LeaderElector<T>`	`getLeaderElector(String name)` Gets or creates a `LeaderElector`.
`<E> DistributedList<E>`	`getList(String name)` Gets or creates a `DistributedList`.
`DistributedLock`	`getLock(String name)` Gets or creates a `DistributedLock`.
`<K,V> DistributedMap<K,V>`	`getMap(String name)` Gets or creates a `DistributedMap`.
`<K,V> DistributedMultimap<K,V>`	`getMultimap(String name)` Gets or creates a `DistributedMultimap`.
`<E> DistributedMultiset<E>`	`getMultiset(String name)` Gets or creates a `DistributedMultiset`.
`<K extends Comparable<K>,V> DistributedNavigableMap<K,V>`	`getNavigableMap(String name)` Gets or creates a `DistributedNavigableMap`.
`<E extends Comparable<E>> DistributedNavigableSet<E>`	`getNavigableSet(String name)` Gets or creates a `DistributedNavigableSet`.
`PartitionService`	`getPartitionService()` Returns the partition service.
`<P extends SyncPrimitive> CompletableFuture<P>`	`getPrimitiveAsync(String name, PrimitiveType<?,?,P> primitiveType)` Gets or creates a distributed primitive asynchronously.
`<C extends PrimitiveConfig<C>,P extends SyncPrimitive> CompletableFuture<P>`	`getPrimitiveAsync(String name, PrimitiveType<?,C,P> primitiveType, C primitiveConfig)` Gets or creates a distributed primitive asynchronously.
`Collection<PrimitiveInfo>`	`getPrimitives()` Returns a collection of open primitives.
`Collection<PrimitiveInfo>`	`getPrimitives(PrimitiveType primitiveType)` Returns a collection of open primitives of the given type.
`PrimitivesService`	`getPrimitivesService()` Returns the primitives service.
`PrimitiveType`	`getPrimitiveType(String typeName)` Returns a primitive type by name.
`<E> DistributedQueue<E>`	`getQueue(String name)` Gets or creates a `DistributedQueue`.
`AtomixRegistry`	`getRegistry()` Returns the Atomix registry service.
`DistributedSemaphore`	`getSemaphore(String name)` Gets or creates a `DistributedSemaphore`.
`SerializationService`	`getSerializationService()` Returns the primitive serialization service.
`<E> DistributedSet<E>`	`getSet(String name)` Gets or creates a `DistributedSet`.
`<K extends Comparable<K>,V> DistributedSortedMap<K,V>`	`getSortedMap(String name)` Gets or creates a `DistributedSortedMap`.
`<E extends Comparable<E>> DistributedSortedSet<E>`	`getSortedSet(String name)` Gets or creates a `DistributedSortedSet`.
`TransactionService`	`getTransactionService()` Returns the transaction service.
`<V> DistributedValue<V>`	`getValue(String name)` Gets or creates a `DistributedValue`.
`<E> WorkQueue<E>`	`getWorkQueue(String name)` Gets or creates a `WorkQueue`.
`<B extends PrimitiveBuilder<B,C,P>,C extends PrimitiveConfig<C>,P extends SyncPrimitive> B`	`primitiveBuilder(String name, PrimitiveType<B,C,P> primitiveType)` Creates a new named primitive builder of the given `primitiveType`.
`CompletableFuture<Void>`	`start()` Starts the Atomix instance.
`CompletableFuture<Void>`	`stop()` Stops the managed object.
`String`	`toString()`
`TransactionBuilder`	`transactionBuilder(String name)` Creates a new transaction builder.

Methods inherited from class io.atomix.cluster.AtomixCluster
builder, getBroadcastService, getCommunicationService, getEventService, getMembershipService, getMessagingService, isRunning

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.atomix.primitive.PrimitiveFactory
getPrimitive, getPrimitive

- Constructor Detail
  - Atomix
```
public Atomix(String... configFiles)
```
  - Atomix
```
public Atomix(ClassLoader classLoader,
              String... configFiles)
```
  - Atomix
```
public Atomix(File... configFiles)
```
  - Atomix
```
public Atomix(ClassLoader classLoader,
              File... configFiles)
```
  - Atomix
```
public Atomix(ClassLoader classLoader,
              List<File> configFiles)
```
- Method Detail
  - config
```
public static AtomixConfig config()
```
    Returns a new Atomix configuration.
    The configuration will be loaded from atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Returns:
    
    a new Atomix configuration
  - config
```
public static AtomixConfig config(ClassLoader classLoader)
```
    Returns a new Atomix configuration.
    The configuration will be loaded from atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    classLoader - the class loader
    
    Returns:
    
    a new Atomix configuration
  - config
```
public static AtomixConfig config(String... files)
```
    Returns a new Atomix configuration from the given file.
    The configuration will be loaded from the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    files - the file from which to return a new Atomix configuration
    
    Returns:
    
    a new Atomix configuration from the given file
  - config
```
public static AtomixConfig config(ClassLoader classLoader,
                                  String... files)
```
    Returns a new Atomix configuration from the given file.
    The configuration will be loaded from the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    classLoader - the class loader
    
    files - the file from which to return a new Atomix configuration
    
    Returns:
    
    a new Atomix configuration from the given file
  - config
```
public static AtomixConfig config(File... configFiles)
```
    Returns a new Atomix configuration.
    The configuration will be loaded from the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    configFiles - the Atomix configuration files
    
    Returns:
    
    a new Atomix configuration
  - config
```
public static AtomixConfig config(List<File> files)
```
    Returns a new Atomix configuration from the given file.
    The configuration will be loaded from the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    files - the file from which to return a new Atomix configuration
    
    Returns:
    
    a new Atomix configuration from the given file
  - config
```
public static AtomixConfig config(ClassLoader classLoader,
                                  List<File> files)
```
    Returns a new Atomix configuration from the given file.
    The configuration will be loaded from the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    classLoader - the class loader
    
    files - the file from which to return a new Atomix configuration
    
    Returns:
    
    a new Atomix configuration from the given file
  - builder
```
public static AtomixBuilder builder()
```
    Returns a new Atomix builder.
    The builder will be initialized with the configuration in atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Returns:
    
    a new Atomix builder
  - builder
```
public static AtomixBuilder builder(ClassLoader classLoader)
```
    Returns a new Atomix builder.
    The builder will be initialized with the configuration in atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    classLoader - the class loader
    
    Returns:
    
    a new Atomix builder
  - builder
```
public static AtomixBuilder builder(String config)
```
    Returns a new Atomix builder.
    The builder will be initialized with the configuration in the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    config - the Atomix configuration
    
    Returns:
    
    a new Atomix builder
  - builder
```
public static AtomixBuilder builder(String configFile,
                                    ClassLoader classLoader)
```
    Returns a new Atomix builder.
    The builder will be initialized with the configuration in the given file and will fall back to atomix.conf, atomix.json, or atomix.properties if located on the classpath.
    
    Parameters:
    
    configFile - the Atomix configuration file
    
    classLoader - the class loader
    
    Returns:
    
    a new Atomix builder
  - builder
```
public static AtomixBuilder builder(AtomixConfig config)
```
    Returns a new Atomix builder.
    The returned builder will be initialized with the provided configuration.
    
    Parameters:
    
    config - the Atomix configuration
    
    Returns:
    
    the Atomix builder
  - builder
```
public static AtomixBuilder builder(AtomixConfig config,
                                    ClassLoader classLoader)
```
    Returns a new Atomix builder.
    The returned builder will be initialized with the provided configuration.
    
    Parameters:
    
    config - the Atomix configuration
    
    classLoader - the class loader with which to load the Atomix registry
    
    Returns:
    
    the Atomix builder
  - getRegistry
```
public AtomixRegistry getRegistry()
```
    Returns the Atomix registry service.
    The registry contains references to all registered Atomix extensions.
    
    Returns:
    
    the Atomix registry service
  - getExecutorService
```
public ScheduledExecutorService getExecutorService()
```
    Returns the core Atomix executor service.
    
    Returns:
    
    the core Atomix executor service
  - getConfigService
```
public ConfigService getConfigService()
```
    Returns the primitive configuration service.
    The primitive configuration service provides all pre-defined named primitive configurations.
    
    Returns:
    
    the primitive configuration service
  - getSerializationService
```
public SerializationService getSerializationService()
```
    Returns the primitive serialization service.
    
    Returns:
    
    the primitive serialization service
  - getPartitionService
```
public PartitionService getPartitionService()
```
    Returns the partition service.
    The partition service is responsible for managing the lifecycle of primitive partitions and can provide information about active partition groups and partitions in the cluster.
    
    Returns:
    
    the partition service
  - getPrimitivesService
```
public PrimitivesService getPrimitivesService()
```
    Returns the primitives service.
    The primitives service is responsible for managing the lifecycle of local primitive instances and can provide information about all primitives registered in the cluster.
    
    Returns:
    
    the primitives service
  - getTransactionService
```
public TransactionService getTransactionService()
```
    Returns the transaction service.
    The transaction service is responsible for managing the lifecycle of all transactions in the cluster and can provide information about currently active transactions.
    
    Returns:
    
    the transaction service
  - transactionBuilder
```
public TransactionBuilder transactionBuilder(String name)
```
    Description copied from interface: PrimitivesService
    Creates a new transaction builder.
    To get an asynchronous instance of the transaction, use the SyncPrimitive.async() method:
```
   
   AsyncTransaction transaction = atomix.transactionBuilder().build().async();
   
 
```
    Specified by:
    
    transactionBuilder in interface PrimitivesService
    
    Parameters:
    
    name - the transaction name
    
    Returns:
    
    the transaction builder
  - primitiveBuilder
```
public <B extends PrimitiveBuilder<B,C,P>,C extends PrimitiveConfig<C>,P extends SyncPrimitive> B primitiveBuilder(String name,
                                                                                                                   PrimitiveType<B,C,P> primitiveType)
```
    Description copied from interface: PrimitiveFactory
    Creates a new named primitive builder of the given primitiveType.
    The primitive name must be provided when constructing the builder. The name is used to reference a distinct instance of the primitive within the cluster. Multiple instances of the primitive with the same name will share the same state. However, the instance of the primitive constructed by the returned builder will be distinct and will not share local memory (e.g. cache) with any other instance on this node.
    To get an asynchronous instance of the primitive, use the SyncPrimitive.async() method:
```
   
   AsyncPrimitive async = atomix.primitiveBuilder("my-primitive", MyPrimitiveType.instance()).build().async();
   
 
```
    Specified by:
    
    primitiveBuilder in interface PrimitiveFactory
    
    Type Parameters:
    
    B - the primitive builder type
    
    P - the primitive type
    
    Parameters:
    
    name - the primitive name
    
    primitiveType - the primitive type
    
    Returns:
    
    the primitive builder
  - getMap
```
public <K,V> DistributedMap<K,V> getMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedMap<String, String> map = atomix.getMap("my-map").async();
   
 
```
    Specified by:
    
    getMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new distributed map
  - getSortedMap
```
public <K extends Comparable<K>,V> DistributedSortedMap<K,V> getSortedMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedSortedMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedSortedMap<String, String> map = atomix.getSortedMap("my-map").async();
   
 
```
    Specified by:
    
    getSortedMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new distributed map
  - getNavigableMap
```
public <K extends Comparable<K>,V> DistributedNavigableMap<K,V> getNavigableMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedNavigableMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedNavigableMap<String, String> map = atomix.getNavigableMap("my-map").async();
   
 
```
    Specified by:
    
    getNavigableMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new distributed map
  - getMultimap
```
public <K,V> DistributedMultimap<K,V> getMultimap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedMultimap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the multimap, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedMultimap<String, String> multimap = atomix.getMultimap("my-multimap").async();
   
 
```
    Specified by:
    
    getMultimap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new distributed multimap
  - getAtomicMap
```
public <K,V> AtomicMap<K,V> getAtomicMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicMap<String, String> map = atomix.getAtomicMap("my-map").async();
   
 
```
    Specified by:
    
    getAtomicMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new atomic map
  - getAtomicDocumentTree
```
public <V> AtomicDocumentTree<V> getAtomicDocumentTree(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicDocumentTree.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the tree, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicDocumentTree<String> map = atomix.getDocumentTree("my-tree").async();
   
 
```
    Specified by:
    
    getAtomicDocumentTree in interface PrimitivesService
    
    Type Parameters:
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new atomic map
  - getAtomicSortedMap
```
public <K extends Comparable<K>,V> AtomicSortedMap<K,V> getAtomicSortedMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicSortedMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicSortedMap<String, String> map = atomix.getAtomicSortedMap("my-map").async();
   
 
```
    Specified by:
    
    getAtomicSortedMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new atomic tree map
  - getAtomicNavigableMap
```
public <K extends Comparable<K>,V> AtomicNavigableMap<K,V> getAtomicNavigableMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicNavigableMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicNavigableMap<String, String> map = atomix.getAtomicNavigableMap("my-map").async();
   
 
```
    Specified by:
    
    getAtomicNavigableMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new atomic tree map
  - getAtomicMultimap
```
public <K,V> AtomicMultimap<K,V> getAtomicMultimap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicMultimap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the multimap, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicMultimap<String, String> multimap = atomix.getAtomicMultimap("my-multimap").async();
   
 
```
    Specified by:
    
    getAtomicMultimap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new atomic tree map
  - getAtomicCounterMap
```
public <K> AtomicCounterMap<K> getAtomicCounterMap(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicCounterMap.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the map, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicCounterMap<String> map = atomix.getAtomicCounterMap("my-counter-map").async();
   
 
```
    Specified by:
    
    getAtomicCounterMap in interface PrimitivesService
    
    Type Parameters:
    
    K - key type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a new atomic counter map
  - getSet
```
public <E> DistributedSet<E> getSet(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedSet.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the set, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedSet<String> set = atomix.getSet("my-set").async();
   
 
```
    Specified by:
    
    getSet in interface PrimitivesService
    
    Type Parameters:
    
    E - set element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a multiton instance of a distributed set
  - getSortedSet
```
public <E extends Comparable<E>> DistributedSortedSet<E> getSortedSet(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedSortedSet.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the set, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedSortedSet<String> set = atomix.getSortedSet("my-set").async();
   
 
```
    Specified by:
    
    getSortedSet in interface PrimitivesService
    
    Type Parameters:
    
    E - set element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a multiton instance of a distributed sorted set
  - getNavigableSet
```
public <E extends Comparable<E>> DistributedNavigableSet<E> getNavigableSet(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedNavigableSet.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the set, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedNavigableSet<String> set = atomix.getNavigableSet("my-set").async();
   
 
```
    Specified by:
    
    getNavigableSet in interface PrimitivesService
    
    Type Parameters:
    
    E - set element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a multiton instance of a distributed navigable set
  - getQueue
```
public <E> DistributedQueue<E> getQueue(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedQueue.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the queue, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedQueue<String> queue = atomix.getQueue("my-queue").async();
   
 
```
    Specified by:
    
    getQueue in interface PrimitivesService
    
    Type Parameters:
    
    E - queue element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a multiton instance of a distributed queue
  - getList
```
public <E> DistributedList<E> getList(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedList.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the list, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedList<String> list = atomix.getList("my-list").async();
   
 
```
    Specified by:
    
    getList in interface PrimitivesService
    
    Type Parameters:
    
    E - list element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a multiton instance of a distributed list
  - getMultiset
```
public <E> DistributedMultiset<E> getMultiset(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedMultiset.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the multiset, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedMultiset<String> multiset = atomix.getMultiset("my-multiset").async();
   
 
```
    Specified by:
    
    getMultiset in interface PrimitivesService
    
    Type Parameters:
    
    E - multiset element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    a multiton instance of a distributed multiset
  - getCounter
```
public DistributedCounter getCounter(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedCounter.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the counter, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedCounter counter = atomix.getCounter("my-counter").async();
   
 
```
    Specified by:
    
    getCounter in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    distributed counter
  - getAtomicCounter
```
public AtomicCounter getAtomicCounter(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicCounter.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the counter, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicCounter counter = atomix.getAtomicCounter("my-counter").async();
   
 
```
    Specified by:
    
    getAtomicCounter in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    atomic counter builder
  - getAtomicIdGenerator
```
public AtomicIdGenerator getAtomicIdGenerator(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicIdGenerator.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the ID generator, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicIdGenerator idGenerator = atomix.getAtomicIdGenerator("my-id-generator").async();
   
 
```
    Specified by:
    
    getAtomicIdGenerator in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    atomic ID generator builder
  - getValue
```
public <V> DistributedValue<V> getValue(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedValue.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the value, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedValue<String> value = atomix.getValue("my-value").async();
   
 
```
    Specified by:
    
    getValue in interface PrimitivesService
    
    Type Parameters:
    
    V - value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    distributed value
  - getAtomicValue
```
public <V> AtomicValue<V> getAtomicValue(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicValue.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the value, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicValue<String> value = atomix.getAtomicValue("my-value").async();
   
 
```
    Specified by:
    
    getAtomicValue in interface PrimitivesService
    
    Type Parameters:
    
    V - atomic value type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    atomic value builder
  - getLeaderElection
```
public <T> LeaderElection<T> getLeaderElection(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a LeaderElection.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the election, use the SyncPrimitive.async() method:
```
   
   AsyncLeaderElection<String> election = atomix.getLeaderElection("my-election").async();
   
 
```
    Specified by:
    
    getLeaderElection in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    leader election builder
  - getLeaderElector
```
public <T> LeaderElector<T> getLeaderElector(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a LeaderElector.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the elector, use the SyncPrimitive.async() method:
```
   
   AsyncLeaderElector<String> elector = atomix.getLeaderElector("my-elector").async();
   
 
```
    Specified by:
    
    getLeaderElector in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    leader elector builder
  - getLock
```
public DistributedLock getLock(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedLock.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the lock, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedLock lock = atomix.getLock("my-lock").async();
   
 
```
    Specified by:
    
    getLock in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    atomic lock builder
  - getAtomicLock
```
public AtomicLock getAtomicLock(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicLock.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the lock, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicLock lock = atomix.getAtomicLock("my-lock").async();
   
 
```
    Specified by:
    
    getAtomicLock in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    atomic lock builder
  - getCyclicBarrier
```
public DistributedCyclicBarrier getCyclicBarrier(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedCyclicBarrier.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the barrier, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedCyclicBarrier barrier = atomix.getCyclicBarrier("my-barrier").async();
   
 
```
    Specified by:
    
    getCyclicBarrier in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    the cyclic barrier
  - getSemaphore
```
public DistributedSemaphore getSemaphore(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a DistributedSemaphore.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the semaphore, use the SyncPrimitive.async() method:
```
   
   AsyncDistributedSemaphore semaphore = atomix.getSemaphore("my-semaphore").async();
   
 
```
    Specified by:
    
    getSemaphore in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    DistributedSemaphore
  - getAtomicSemaphore
```
public AtomicSemaphore getAtomicSemaphore(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a AtomicSemaphore.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the semaphore, use the SyncPrimitive.async() method:
```
   
   AsyncAtomicSemaphore semaphore = atomix.getAtomicSemaphore("my-semaphore").async();
   
 
```
    Specified by:
    
    getAtomicSemaphore in interface PrimitivesService
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    DistributedSemaphore
  - getWorkQueue
```
public <E> WorkQueue<E> getWorkQueue(String name)
```
    Description copied from interface: PrimitivesService
    Gets or creates a WorkQueue.
    A new primitive will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    To get an asynchronous instance of the work queue, use the SyncPrimitive.async() method:
```
   
   AsyncWorkQueue<String> workQueue = atomix.getWorkQueue("my-work-queue").async();
   
 
```
    Specified by:
    
    getWorkQueue in interface PrimitivesService
    
    Type Parameters:
    
    E - work queue element type
    
    Parameters:
    
    name - the primitive name
    
    Returns:
    
    work queue builder
  - getPrimitiveType
```
public PrimitiveType getPrimitiveType(String typeName)
```
    Description copied from interface: PrimitiveFactory
    
    Returns a primitive type by name.
    
    Specified by:
    
    getPrimitiveType in interface PrimitiveFactory
    
    Parameters:
    
    typeName - the primitive type name
    
    Returns:
    
    the primitive type
  - getPrimitiveAsync
```
public <P extends SyncPrimitive> CompletableFuture<P> getPrimitiveAsync(String name,
                                                                        PrimitiveType<?,?,P> primitiveType)
```
    Description copied from interface: PrimitiveFactory
    
    Gets or creates a distributed primitive asynchronously.
    A new primitive of the given primitiveType will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    
    Specified by:
    
    getPrimitiveAsync in interface PrimitiveFactory
    
    Type Parameters:
    
    P - the primitive type
    
    Parameters:
    
    name - the primitive name
    
    primitiveType - the primitive type
    
    Returns:
    
    the primitive instance
  - getPrimitiveAsync
```
public <C extends PrimitiveConfig<C>,P extends SyncPrimitive> CompletableFuture<P> getPrimitiveAsync(String name,
                                                                                                     PrimitiveType<?,C,P> primitiveType,
                                                                                                     C primitiveConfig)
```
    Description copied from interface: PrimitiveFactory
    
    Gets or creates a distributed primitive asynchronously.
    A new primitive of the given primitiveType will be created if no primitive instance with the given name exists on this node, otherwise the existing instance will be returned. The name is used to reference a distinct instance of the primitive within the cluster. The returned primitive will share the same state with primitives of the same name on other nodes.
    When the instance is initially constructed, it will be configured with any pre-existing primitive configuration defined in atomix.conf.
    
    Specified by:
    
    getPrimitiveAsync in interface PrimitiveFactory
    
    Type Parameters:
    
    C - the primitive configuration type
    
    P - the primitive type
    
    Parameters:
    
    name - the primitive name
    
    primitiveType - the primitive type
    
    primitiveConfig - the primitive configuration
    
    Returns:
    
    a future to be completed with the primitive instance
  - getPrimitives
```
public Collection<PrimitiveInfo> getPrimitives()
```
    Description copied from interface: PrimitiveFactory
    
    Returns a collection of open primitives.
    
    Specified by:
    
    getPrimitives in interface PrimitiveFactory
    
    Returns:
    
    a collection of open primitives
  - getPrimitives
```
public Collection<PrimitiveInfo> getPrimitives(PrimitiveType primitiveType)
```
    Description copied from interface: PrimitiveFactory
    
    Returns a collection of open primitives of the given type.
    
    Specified by:
    
    getPrimitives in interface PrimitiveFactory
    
    Parameters:
    
    primitiveType - the primitive type
    
    Returns:
    
    a collection of open primitives of the given type
  - start
```
public CompletableFuture<Void> start()
```
    Starts the Atomix instance.
    The returned future will be completed once this instance completes startup. Note that in order to complete startup, all partitions must be able to form. For Raft partitions, that requires that a majority of the nodes in each partition be started concurrently.
    
    Specified by:
    
    start in interface Managed<Void>
    
    Overrides:
    
    start in class AtomixCluster
    
    Returns:
    
    a future to be completed once the instance has completed startup
  - stop
```
public CompletableFuture<Void> stop()
```
    Description copied from interface: Managed
    
    Stops the managed object.
    
    Specified by:
    
    stop in interface Managed<Void>
    
    Overrides:
    
    stop in class AtomixCluster
    
    Returns:
    
    A completable future to be completed once the object has been stopped.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AtomixCluster

Class Atomix

Constructor Summary

Method Summary

Methods inherited from class io.atomix.cluster.AtomixCluster

Methods inherited from class java.lang.Object

Methods inherited from interface io.atomix.core.PrimitivesService

Methods inherited from interface io.atomix.primitive.PrimitiveFactory

Constructor Detail

Atomix

Atomix

Atomix

Atomix

Atomix

Method Detail

config

config

config

config

config

config

config

builder

builder

builder

builder

builder

builder

getRegistry

getExecutorService

getConfigService

getSerializationService

getPartitionService

getPrimitivesService

getTransactionService

transactionBuilder

primitiveBuilder

getMap

getSortedMap

getNavigableMap

getMultimap

getAtomicMap

getAtomicDocumentTree

getAtomicSortedMap

getAtomicNavigableMap

getAtomicMultimap

getAtomicCounterMap

getSet

getSortedSet

getNavigableSet

getQueue

getList

getMultiset

getCounter

getAtomicCounter

getAtomicIdGenerator

getValue

getAtomicValue

getLeaderElection

getLeaderElector

getLock

getAtomicLock

getCyclicBarrier

getSemaphore

getAtomicSemaphore

getWorkQueue

getPrimitiveType

getPrimitiveAsync

getPrimitiveAsync

getPrimitives

getPrimitives

start

stop

toString