java.lang.Object
- io.vertx.mutiny.core.shareddata.Counter

```
public class Counter
extends Object
```
An asynchronous counter that can be used to across the cluster to maintain a consistent count.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field Description

static TypeArg<Counter> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

Counter(io.vertx.core.shareddata.Counter delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`io.smallrye.mutiny.Uni<Long>`	`addAndGet(long value)`	Add the value to the counter atomically and return the new count
`Long`	`addAndGetAndAwait(long value)`	Blocking variant of `addAndGet(long)`.
`io.smallrye.mutiny.Uni<Boolean>`	`compareAndSet(long expected, long value)`	Set the counter to the specified value only if the current value is the expectec value.
`Boolean`	`compareAndSetAndAwait(long expected, long value)`	Blocking variant of `compareAndSet(long,long)`.
`io.smallrye.mutiny.Uni<Long>`	`decrementAndGet()`	Decrement the counter atomically and return the new count
`Long`	`decrementAndGetAndAwait()`	Blocking variant of `decrementAndGet()`.
`boolean`	`equals(Object o)`
`io.smallrye.mutiny.Uni<Long>`	`get()`	Get the current value of the counter
`io.smallrye.mutiny.Uni<Long>`	`getAndAdd(long value)`	Add the value to the counter atomically and return the value before the add
`Long`	`getAndAddAndAwait(long value)`	Blocking variant of `getAndAdd(long)`.
`Long`	`getAndAwait()`	Blocking variant of `get()`.
`io.smallrye.mutiny.Uni<Long>`	`getAndIncrement()`	Increment the counter atomically and return the value before the increment.
`Long`	`getAndIncrementAndAwait()`	Blocking variant of `getAndIncrement()`.
`io.vertx.core.shareddata.Counter`	`getDelegate()`
`int`	`hashCode()`
`io.smallrye.mutiny.Uni<Long>`	`incrementAndGet()`	Increment the counter atomically and return the new count
`Long`	`incrementAndGetAndAwait()`	Blocking variant of `incrementAndGet()`.
`static Counter`	`newInstance(io.vertx.core.shareddata.Counter arg)`
`String`	`toString()`

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

- Field Detail
  - __TYPE_ARG
```
public static final TypeArg<Counter> __TYPE_ARG
```
- Constructor Detail
  - Counter
```
public Counter(io.vertx.core.shareddata.Counter delegate)
```
- Method Detail
  - getDelegate
```
public io.vertx.core.shareddata.Counter getDelegate()
```
  - 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
  - get
```
public io.smallrye.mutiny.Uni<Long> get()
```
    Get the current value of the counter
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getAndAwait
```
public Long getAndAwait()
```
    Blocking variant of get().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Long instance produced by the operation
  - incrementAndGet
```
public io.smallrye.mutiny.Uni<Long> incrementAndGet()
```
    Increment the counter atomically and return the new count
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - incrementAndGetAndAwait
```
public Long incrementAndGetAndAwait()
```
    Blocking variant of incrementAndGet().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Long instance produced by the operation
  - getAndIncrement
```
public io.smallrye.mutiny.Uni<Long> getAndIncrement()
```
    Increment the counter atomically and return the value before the increment.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getAndIncrementAndAwait
```
public Long getAndIncrementAndAwait()
```
    Blocking variant of getAndIncrement().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Long instance produced by the operation
  - decrementAndGet
```
public io.smallrye.mutiny.Uni<Long> decrementAndGet()
```
    Decrement the counter atomically and return the new count
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - decrementAndGetAndAwait
```
public Long decrementAndGetAndAwait()
```
    Blocking variant of decrementAndGet().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Long instance produced by the operation
  - addAndGet
```
public io.smallrye.mutiny.Uni<Long> addAndGet(long value)
```
    Add the value to the counter atomically and return the new count
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    value - the value to add
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - addAndGetAndAwait
```
public Long addAndGetAndAwait(long value)
```
    Blocking variant of addAndGet(long).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    value - the value to add
    
    Returns:
    
    the Long instance produced by the operation
  - getAndAdd
```
public io.smallrye.mutiny.Uni<Long> getAndAdd(long value)
```
    Add the value to the counter atomically and return the value before the add
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    value - the value to add
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getAndAddAndAwait
```
public Long getAndAddAndAwait(long value)
```
    Blocking variant of getAndAdd(long).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    value - the value to add
    
    Returns:
    
    the Long instance produced by the operation
  - compareAndSet
```
public io.smallrye.mutiny.Uni<Boolean> compareAndSet(long expected,
                                                     long value)
```
    Set the counter to the specified value only if the current value is the expectec value. This happens atomically.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    expected - the expected value
    
    value - the new value
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - compareAndSetAndAwait
```
public Boolean compareAndSetAndAwait(long expected,
                                     long value)
```
    Blocking variant of compareAndSet(long,long).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    expected - the expected value
    
    value - the new value
    
    Returns:
    
    the Boolean instance produced by the operation
  - newInstance
```
public static Counter newInstance(io.vertx.core.shareddata.Counter arg)
```

Class Counter

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

Counter

Method Detail

getDelegate

toString

equals

hashCode

get

getAndAwait

incrementAndGet

incrementAndGetAndAwait

getAndIncrement

getAndIncrementAndAwait

decrementAndGet

decrementAndGetAndAwait

addAndGet

addAndGetAndAwait

getAndAdd

getAndAddAndAwait

compareAndSet

compareAndSetAndAwait

newInstance