SharedData (Vert.x Stack - Docs 3.9.15 API)

java.lang.Object
- io.vertx.rxjava.core.shareddata.SharedData

```
public class SharedData
extends Object
```
Shared data allows you to share data safely between different parts of your application in a safe way.
Shared data provides:
- synchronous shared maps (local)
- asynchronous maps (local or cluster-wide)
- asynchronous locks (local or cluster-wide)
- asynchronous counters (local or cluster-wide)
WARNING: In clustered mode, asynchronous maps/locks/counters rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous maps/locks/counters operations can be much higher in clustered than in local mode.
Please see the documentation for more information.
NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field and Description

static io.vertx.lang.rx.TypeArg<SharedData> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<SharedData>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

SharedData(Object delegate)

SharedData(SharedData delegate)

Constructors
Constructor and Description
`SharedData(Object delegate)`
`SharedData(SharedData delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`equals(Object o)`
`<K,V> void`	`getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
`<K,V> Observable<AsyncMap<K,V>>`	`getAsyncMapObservable(String name)` Deprecated. use `rxGetAsyncMap(java.lang.String)` instead
`<K,V> void`	`getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the cluster wide map with the specified name.
`<K,V> Observable<AsyncMap<K,V>>`	`getClusterWideMapObservable(String name)` Deprecated. use `rxGetClusterWideMap(java.lang.String)` instead
`void`	`getCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous counter.
`Observable<Counter>`	`getCounterObservable(String name)` Deprecated. use `rxGetCounter(java.lang.String)` instead
`SharedData`	`getDelegate()`
`<K,V> void`	`getLocalAsyncMap(String name, Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)` Get the `AsyncMap` with the specified name.
`<K,V> Observable<AsyncMap<K,V>>`	`getLocalAsyncMapObservable(String name)` Deprecated. use `rxGetLocalAsyncMap(java.lang.String)` instead
`void`	`getLocalCounter(String name, Handler<AsyncResult<Counter>> resultHandler)` Get an asynchronous local counter.
`Observable<Counter>`	`getLocalCounterObservable(String name)` Deprecated. use `rxGetLocalCounter(java.lang.String)` instead
`void`	`getLocalLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous local lock with the specified name.
`Observable<Lock>`	`getLocalLockObservable(String name)` Deprecated. use `rxGetLocalLock(java.lang.String)` instead
`void`	`getLocalLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
`Observable<Lock>`	`getLocalLockWithTimeoutObservable(String name, long timeout)` Deprecated. use `rxGetLocalLockWithTimeout(java.lang.String, long)` instead
`<K,V> LocalMap<K,V>`	`getLocalMap(String name)` Return a `LocalMap` with the specific `name`.
`void`	`getLock(String name, Handler<AsyncResult<Lock>> resultHandler)` Get an asynchronous lock with the specified name.
`Observable<Lock>`	`getLockObservable(String name)` Deprecated. use `rxGetLock(java.lang.String)` instead
`void`	`getLockWithTimeout(String name, long timeout, Handler<AsyncResult<Lock>> resultHandler)` Like `getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
`Observable<Lock>`	`getLockWithTimeoutObservable(String name, long timeout)` Deprecated. use `rxGetLockWithTimeout(java.lang.String, long)` instead
`int`	`hashCode()`
`static SharedData`	`newInstance(SharedData arg)`
`<K,V> Single<AsyncMap<K,V>>`	`rxGetAsyncMap(String name)` Get the `AsyncMap` with the specified name.
`<K,V> Single<AsyncMap<K,V>>`	`rxGetClusterWideMap(String name)` Get the cluster wide map with the specified name.
`Single<Counter>`	`rxGetCounter(String name)` Get an asynchronous counter.
`<K,V> Single<AsyncMap<K,V>>`	`rxGetLocalAsyncMap(String name)` Get the `AsyncMap` with the specified name.
`Single<Counter>`	`rxGetLocalCounter(String name)` Get an asynchronous local counter.
`Single<Lock>`	`rxGetLocalLock(String name)` Get an asynchronous local lock with the specified name.
`Single<Lock>`	`rxGetLocalLockWithTimeout(String name, long timeout)` Like `getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
`Single<Lock>`	`rxGetLock(String name)` Get an asynchronous lock with the specified name.
`Single<Lock>`	`rxGetLockWithTimeout(String name, long timeout)` Like `getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>)` but specifying a timeout.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final io.vertx.lang.rx.TypeArg<SharedData> __TYPE_ARG
```
- Constructor Detail
  - SharedData
```
public SharedData(SharedData delegate)
```
  - SharedData
```
public SharedData(Object delegate)
```
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getDelegate
```
public SharedData getDelegate()
```
  - getClusterWideMap
```
public <K,V> void getClusterWideMap(String name,
                                    Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
```
    Get the cluster wide map with the specified name. The map is accessible to all nodes in the cluster and data put into the map from any node is visible to to any other node.
    
    Parameters:
    
    name - the name of the map
    
    resultHandler - the map will be returned asynchronously in this handler
  - getClusterWideMapObservable
```
@Deprecated
public <K,V> Observable<AsyncMap<K,V>> getClusterWideMapObservable(String name)
```
    Deprecated. use rxGetClusterWideMap(java.lang.String) instead
    
    Get the cluster wide map with the specified name. The map is accessible to all nodes in the cluster and data put into the map from any node is visible to to any other node.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
  - rxGetClusterWideMap
```
public <K,V> Single<AsyncMap<K,V>> rxGetClusterWideMap(String name)
```
    Get the cluster wide map with the specified name. The map is accessible to all nodes in the cluster and data put into the map from any node is visible to to any other node.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
  - getAsyncMap
```
public <K,V> void getAsyncMap(String name,
                              Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
```
    Get the AsyncMap with the specified name. When clustered, the map is accessible to all nodes in the cluster and data put into the map from any node is visible to to any other node.
    WARNING: In clustered mode, asynchronous shared maps rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous shared maps operations can be much higher in clustered than in local mode.
    
    Parameters:
    
    name - the name of the map
    
    resultHandler - the map will be returned asynchronously in this handler
  - getAsyncMapObservable
```
@Deprecated
public <K,V> Observable<AsyncMap<K,V>> getAsyncMapObservable(String name)
```
    Deprecated. use rxGetAsyncMap(java.lang.String) instead
    
    Get the AsyncMap with the specified name. When clustered, the map is accessible to all nodes in the cluster and data put into the map from any node is visible to to any other node.
    WARNING: In clustered mode, asynchronous shared maps rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous shared maps operations can be much higher in clustered than in local mode.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
  - rxGetAsyncMap
```
public <K,V> Single<AsyncMap<K,V>> rxGetAsyncMap(String name)
```
    Get the AsyncMap with the specified name. When clustered, the map is accessible to all nodes in the cluster and data put into the map from any node is visible to to any other node.
    WARNING: In clustered mode, asynchronous shared maps rely on distributed data structures provided by the cluster manager. Beware that the latency relative to asynchronous shared maps operations can be much higher in clustered than in local mode.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
  - getLocalAsyncMap
```
public <K,V> void getLocalAsyncMap(String name,
                                   Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
```
    Get the AsyncMap with the specified name.
    When clustered, the map is NOT accessible to all nodes in the cluster. Only the instance which created the map can put and retrieve data from this map.
    
    Parameters:
    
    name - the name of the map
    
    resultHandler - the map will be returned asynchronously in this handler
  - getLocalAsyncMapObservable
```
@Deprecated
public <K,V> Observable<AsyncMap<K,V>> getLocalAsyncMapObservable(String name)
```
    Deprecated. use rxGetLocalAsyncMap(java.lang.String) instead
    
    Get the AsyncMap with the specified name.
    When clustered, the map is NOT accessible to all nodes in the cluster. Only the instance which created the map can put and retrieve data from this map.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
  - rxGetLocalAsyncMap
```
public <K,V> Single<AsyncMap<K,V>> rxGetLocalAsyncMap(String name)
```
    Get the AsyncMap with the specified name.
    When clustered, the map is NOT accessible to all nodes in the cluster. Only the instance which created the map can put and retrieve data from this map.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
  - getLock
```
public void getLock(String name,
                    Handler<AsyncResult<Lock>> resultHandler)
```
    Get an asynchronous lock with the specified name. The lock will be passed to the handler when it is available.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    resultHandler - the handler
  - getLockObservable
```
@Deprecated
public Observable<Lock> getLockObservable(String name)
```
    Deprecated. use rxGetLock(java.lang.String) instead
    
    Get an asynchronous lock with the specified name. The lock will be passed to the handler when it is available.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    Returns:
  - rxGetLock
```
public Single<Lock> rxGetLock(String name)
```
    Get an asynchronous lock with the specified name. The lock will be passed to the handler when it is available.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    Returns:
  - getLockWithTimeout
```
public void getLockWithTimeout(String name,
                               long timeout,
                               Handler<AsyncResult<Lock>> resultHandler)
```
    Like getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. If the lock is not obtained within the timeout a failure will be sent to the handler.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    timeout - the timeout in ms
    
    resultHandler - the handler
  - getLockWithTimeoutObservable
```
@Deprecated
public Observable<Lock> getLockWithTimeoutObservable(String name,
                                                                 long timeout)
```
    Deprecated. use rxGetLockWithTimeout(java.lang.String, long) instead
    
    Like getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. If the lock is not obtained within the timeout a failure will be sent to the handler.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    timeout - the timeout in ms
    
    Returns:
  - rxGetLockWithTimeout
```
public Single<Lock> rxGetLockWithTimeout(String name,
                                         long timeout)
```
    Like getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. If the lock is not obtained within the timeout a failure will be sent to the handler.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    timeout - the timeout in ms
    
    Returns:
  - getLocalLock
```
public void getLocalLock(String name,
                         Handler<AsyncResult<Lock>> resultHandler)
```
    Get an asynchronous local lock with the specified name. The lock will be passed to the handler when it is available.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    resultHandler - the handler
  - getLocalLockObservable
```
@Deprecated
public Observable<Lock> getLocalLockObservable(String name)
```
    Deprecated. use rxGetLocalLock(java.lang.String) instead
    
    Get an asynchronous local lock with the specified name. The lock will be passed to the handler when it is available.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    Returns:
  - rxGetLocalLock
```
public Single<Lock> rxGetLocalLock(String name)
```
    Get an asynchronous local lock with the specified name. The lock will be passed to the handler when it is available.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    Returns:
  - getLocalLockWithTimeout
```
public void getLocalLockWithTimeout(String name,
                                    long timeout,
                                    Handler<AsyncResult<Lock>> resultHandler)
```
    Like getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. If the lock is not obtained within the timeout a failure will be sent to the handler.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    timeout - the timeout in ms
    
    resultHandler - the handler
  - getLocalLockWithTimeoutObservable
```
@Deprecated
public Observable<Lock> getLocalLockWithTimeoutObservable(String name,
                                                                      long timeout)
```
    Deprecated. use rxGetLocalLockWithTimeout(java.lang.String, long) instead
    
    Like getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. If the lock is not obtained within the timeout a failure will be sent to the handler.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    timeout - the timeout in ms
    
    Returns:
  - rxGetLocalLockWithTimeout
```
public Single<Lock> rxGetLocalLockWithTimeout(String name,
                                              long timeout)
```
    Like getLocalLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. If the lock is not obtained within the timeout a failure will be sent to the handler.
    In general lock acquision is unordered, so that sequential attempts to acquire a lock, even from a single thread, can happen in non-sequential order.
    
    Parameters:
    
    name - the name of the lock
    
    timeout - the timeout in ms
    
    Returns:
  - getCounter
```
public void getCounter(String name,
                       Handler<AsyncResult<Counter>> resultHandler)
```
    Get an asynchronous counter. The counter will be passed to the handler.
    
    Parameters:
    
    name - the name of the counter.
    
    resultHandler - the handler
  - getCounterObservable
```
@Deprecated
public Observable<Counter> getCounterObservable(String name)
```
    Deprecated. use rxGetCounter(java.lang.String) instead
    
    Get an asynchronous counter. The counter will be passed to the handler.
    
    Parameters:
    
    name - the name of the counter.
    
    Returns:
  - rxGetCounter
```
public Single<Counter> rxGetCounter(String name)
```
    Get an asynchronous counter. The counter will be passed to the handler.
    
    Parameters:
    
    name - the name of the counter.
    
    Returns:
  - getLocalCounter
```
public void getLocalCounter(String name,
                            Handler<AsyncResult<Counter>> resultHandler)
```
    Get an asynchronous local counter. The counter will be passed to the handler.
    
    Parameters:
    
    name - the name of the counter.
    
    resultHandler - the handler
  - getLocalCounterObservable
```
@Deprecated
public Observable<Counter> getLocalCounterObservable(String name)
```
    Deprecated. use rxGetLocalCounter(java.lang.String) instead
    
    Get an asynchronous local counter. The counter will be passed to the handler.
    
    Parameters:
    
    name - the name of the counter.
    
    Returns:
  - rxGetLocalCounter
```
public Single<Counter> rxGetLocalCounter(String name)
```
    Get an asynchronous local counter. The counter will be passed to the handler.
    
    Parameters:
    
    name - the name of the counter.
    
    Returns:
  - getLocalMap
```
public <K,V> LocalMap<K,V> getLocalMap(String name)
```
    Return a LocalMap with the specific name.
    
    Parameters:
    
    name - the name of the map
    
    Returns:
    
    the msp
  - newInstance
```
public static SharedData newInstance(SharedData arg)
```

Class SharedData

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

SharedData

SharedData

Method Detail

toString

equals

hashCode

getDelegate

getClusterWideMap

getClusterWideMapObservable

rxGetClusterWideMap

getAsyncMap

getAsyncMapObservable

rxGetAsyncMap

getLocalAsyncMap

getLocalAsyncMapObservable

rxGetLocalAsyncMap

getLock

getLockObservable

rxGetLock

getLockWithTimeout

getLockWithTimeoutObservable

rxGetLockWithTimeout

getLocalLock

getLocalLockObservable

rxGetLocalLock

getLocalLockWithTimeout

getLocalLockWithTimeoutObservable

rxGetLocalLockWithTimeout

getCounter

getCounterObservable

rxGetCounter

getLocalCounter

getLocalCounterObservable

rxGetLocalCounter

getLocalMap

newInstance