AtomicChar

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def +=(v: Char): Unit

Definition Classes
AtomicChar → AtomicNumber
final def -=(v: Char): Unit

Definition Classes
AtomicChar → AtomicNumber
final def :=(value: Char): Unit

Alias for set().
Alias for set(). Updates the current value.
value
will be the new value returned by get()

Definition Classes
AtomicChar → Atomic
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def add(v: Char): Unit

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def addAndGet(v: Char): Char

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
def apply(): Char

returns
the current value persisted by this Atomic, an alias for get()

Definition Classes
Atomic
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def compareAndSet(expect: Char, update: Char): Boolean

Does a compare-and-set operation on the current value.
Does a compare-and-set operation on the current value. For more info, checkout the related Compare-and-swap Wikipedia page.
It's an atomic, worry free operation.
expect
is the value you expect to be persisted when the operation happens
update
will be the new value, should the check for expect succeeds
returns
either true in case the operation succeeded or false otherwise

Definition Classes
AtomicChar → Atomic
final def countDownToZero(v: Char = 1): Char

Decrements this number until it reaches zero.
Decrements this number until it reaches zero.
returns
a number representing how much it was able to subtract, which is a value between zero and v

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def decrement(v: Int = 1): Unit

Definition Classes
AtomicChar → AtomicNumber
final def decrementAndGet(v: Int = 1): Char

Definition Classes
AtomicChar → AtomicNumber
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def get: Char

returns
the current value persisted by this Atomic

Definition Classes
AtomicChar → Atomic
final def getAndAdd(v: Char): Char

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def getAndDecrement(v: Int = 1): Char

Definition Classes
AtomicChar → AtomicNumber
final def getAndIncrement(v: Int = 1): Char

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def getAndSet(update: Char): Char

Sets the persisted value to update and returns the old value that was in place.
Sets the persisted value to update and returns the old value that was in place. It's an atomic, worry free operation.

Definition Classes
AtomicChar → Atomic
final def getAndSubtract(v: Char): Char

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def getAndTransform(cb: (Char) ⇒ Char): Char

Abstracts over compareAndSet.
Abstracts over compareAndSet. You specify a transformation by specifying a callback to be executed, a callback that transforms the current value. This method will loop until it will succeed in replacing the current value with the one produced by the given callback.
Note that the callback will be executed on each iteration of the loop, so it can be called multiple times - don't do destructive I/O or operations that mutate global state in it.
cb
is a callback that receives the current value as input and returns the update which is the new value that should be persisted
returns
the old value, just prior to when the successful update happened

Definition Classes
AtomicChar → Atomic
Annotations
@tailrec()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def increment(v: Int = 1): Unit

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def incrementAndGet(v: Int = 1): Char

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def lazySet(update: Char): Unit

Eventually sets to the given value.
Eventually sets to the given value. Has weaker visibility guarantees than the normal set().

Definition Classes
AtomicChar → Atomic
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def set(update: Char): Unit

Updates the current value.
Updates the current value.
update
will be the new value returned by get()

Definition Classes
AtomicChar → Atomic
final def subtract(v: Char): Unit

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def subtractAndGet(v: Char): Char

Definition Classes
AtomicChar → AtomicNumber
Annotations
@tailrec()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def transform(cb: (Char) ⇒ Char): Unit

Abstracts over compareAndSet.
Abstracts over compareAndSet. You specify a transformation by specifying a callback to be executed, a callback that transforms the current value. This method will loop until it will succeed in replacing the current value with the one produced by the given callback.
Note that the callback will be executed on each iteration of the loop, so it can be called multiple times - don't do destructive I/O or operations that mutate global state in it.
cb
is a callback that receives the current value as input and returns the update which is the new value that should be persisted

Definition Classes
AtomicChar → Atomic
Annotations
@tailrec()
final def transformAndExtract[U](cb: (Char) ⇒ (U, Char)): U

Abstracts over compareAndSet.
Abstracts over compareAndSet. You specify a transformation by specifying a callback to be executed, a callback that transforms the current value. This method will loop until it will succeed in replacing the current value with the one produced by your callback.
Note that the callback will be executed on each iteration of the loop, so it can be called multiple times - don't do destructive I/O or operations that mutate global state in it.
cb
is a callback that receives the current value as input and returns a tuple that specifies the update + what should this method return when the operation succeeds.
returns
whatever was specified by your callback, once the operation succeeds

Definition Classes
AtomicChar → Atomic
Annotations
@tailrec()
final def transformAndGet(cb: (Char) ⇒ Char): Char

Abstracts over compareAndSet.
Abstracts over compareAndSet. You specify a transformation by specifying a callback to be executed, a callback that transforms the current value. This method will loop until it will succeed in replacing the current value with the one produced by the given callback.
Note that the callback will be executed on each iteration of the loop, so it can be called multiple times - don't do destructive I/O or operations that mutate global state in it.
cb
is a callback that receives the current value as input and returns the update which is the new value that should be persisted
returns
whatever the update is, after the operation succeeds

Definition Classes
AtomicChar → Atomic
Annotations
@tailrec()
final def update(value: Char): Unit

Alias for set().
Alias for set(). Updates the current value.
value
will be the new value returned by get()

Definition Classes
AtomicChar → Atomic
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def waitForCompareAndSet(expect: Char, update: Char, waitAtMost: FiniteDuration): Unit

Waits until the compareAndSet operation succeeds, e.g...
Waits until the compareAndSet operation succeeds, e.g... 1. until the old value == expected and the operation succeeds, or 2. until the current thread is interrupted, or 3. the specified timeout is due
So this can throw an exception on timeout, useful for when you want to insure that you don't block the current thread ad infinitum
waitAtMost
specifies the timeout, after which this method throws a TimeoutException

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@throws( classOf[InterruptedException] ) @throws( classOf[TimeoutException] )
final def waitForCompareAndSet(expect: Char, update: Char, maxRetries: Int): Boolean

Waits until the compareAndSet operation succeeds, e.g...
Waits until the compareAndSet operation succeeds, e.g...
1. until the old value == expected and the operation succeeds, or 2. until the current thread is interrupted 3. until the the spin lock retried for a maximum of maxRetries
expect
the expected current value
update
the value to replace the current value
maxRetries
the maximum number of times to retry in case of failure
returns
true if the operation succeeded or false in case it failed after it retried for maxRetries times

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@tailrec() @throws( classOf[InterruptedException] )
final def waitForCompareAndSet(expect: Char, update: Char): Unit

Waits until the compareAndSet operation succeeds, e.g...
Waits until the compareAndSet operation succeeds, e.g... 1. until the old value == expected and the operation succeeds, or 2. until the current thread is interrupted

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@tailrec() @throws( classOf[InterruptedException] )
final def waitForCondition(waitAtMost: FiniteDuration, p: (Char) ⇒ Boolean): Unit

Waits until the specified callback, that receives the current value, returns true.
Waits until the specified callback, that receives the current value, returns true. Throws a TimeoutException in case the specified waitAtMost timeout is due.

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@throws( classOf[InterruptedException] ) @throws( classOf[TimeoutException] )
final def waitForCondition(p: (Char) ⇒ Boolean): Unit

Waits until the specified callback, that receives the current value, returns true.
Waits until the specified callback, that receives the current value, returns true.

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@tailrec() @throws( classOf[InterruptedException] )
final def waitForValue(expect: Char, waitAtMost: FiniteDuration): Unit

Waits until the specified expect value == the value stored by this Atomic reference or until the current thread gets interrupted.
Waits until the specified expect value == the value stored by this Atomic reference or until the current thread gets interrupted.
This can throw an exception on timeout, useful for when you want to insure that you don't block the current thread ad infinitum
waitAtMost
specifies the timeout, after which this method throws a TimeoutException

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@throws( classOf[InterruptedException] ) @throws( classOf[TimeoutException] )
final def waitForValue(expect: Char): Unit

Waits until the specified expect value == the value stored by this Atomic reference or until the current thread gets interrupted.
Waits until the specified expect value == the value stored by this Atomic reference or until the current thread gets interrupted.

Definition Classes
AtomicChar → BlockableAtomic
Annotations
@tailrec() @throws( classOf[InterruptedException] )

Related Docs: object AtomicChar | package atomic

class AtomicChar extends AtomicNumber[Char] with BlockableAtomic[Char]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def +=(v: Char): Unit

final def -=(v: Char): Unit

final def :=(value: Char): Unit

final def ==(arg0: Any): Boolean

final def add(v: Char): Unit

final def addAndGet(v: Char): Char

def apply(): Char

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def compareAndSet(expect: Char, update: Char): Boolean

final def countDownToZero(v: Char = 1): Char

final def decrement(v: Int = 1): Unit

final def decrementAndGet(v: Int = 1): Char

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def get: Char

final def getAndAdd(v: Char): Char

final def getAndDecrement(v: Int = 1): Char

final def getAndIncrement(v: Int = 1): Char

final def getAndSet(update: Char): Char

final def getAndSubtract(v: Char): Char

final def getAndTransform(cb: (Char) ⇒ Char): Char

final def getClass(): Class[_]

def hashCode(): Int

final def increment(v: Int = 1): Unit

final def incrementAndGet(v: Int = 1): Char

final def isInstanceOf[T0]: Boolean

final def lazySet(update: Char): Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def set(update: Char): Unit

final def subtract(v: Char): Unit

final def subtractAndGet(v: Char): Char

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def transform(cb: (Char) ⇒ Char): Unit

final def transformAndExtract[U](cb: (Char) ⇒ (U, Char)): U

final def transformAndGet(cb: (Char) ⇒ Char): Char

final def update(value: Char): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def waitForCompareAndSet(expect: Char, update: Char, waitAtMost: FiniteDuration): Unit

final def waitForCompareAndSet(expect: Char, update: Char, maxRetries: Int): Boolean

final def waitForCompareAndSet(expect: Char, update: Char): Unit

final def waitForCondition(waitAtMost: FiniteDuration, p: (Char) ⇒ Boolean): Unit

final def waitForCondition(p: (Char) ⇒ Boolean): Unit

final def waitForValue(expect: Char, waitAtMost: FiniteDuration): Unit

final def waitForValue(expect: Char): Unit

Inherited from BlockableAtomic[Char]

Inherited from AtomicNumber[Char]

Inherited from Atomic[Char]

Inherited from AnyRef

Inherited from Any

Ungrouped