View

Equivalent to atomically executing (if (before == get) { set(after); true } else false), but may be more efficient, especially if there is no enclosing atomic block.

Equivalent to atomically executing (if (before eq get) { set(after); true } else false), but may be more efficient, especially if there is no enclosing atomic block.

Atomically replaces the value ''v'' stored in the Ref with f(''v''), returning the old value. transform should be preferred if the return value is not needed, since it gives the STM more flexibility to avoid transaction conflicts.

Returns a Ref that accesses the same memory location as this view. The returned Ref might be the original reference that was used to construct this view, or it might be a Ref that is equivalent (and ==) to the original.

Works like set(v), but returns the old value. This is an atomic swap, equivalent to atomically performing a get followed by set(v).

Atomically replaces the value ''v'' stored in the Ref with f(''v''). Some Ref implementations may defer execution of f or call f multiple times to avoid transaction conflicts.

Atomically replaces the value ''v'' stored in the Ref with f(''v''), returning the new value. transform should be preferred if the return value is not needed, since it gives the STM more flexibility to avoid transaction conflicts.

Atomically replaces the value ''v'' stored in the Ref with pf(''v'') if pf.isDefinedAt(''v''), returning true, otherwise leaves the element unchanged and returns false. pf.apply and pf.isDefinedAt might be invoked multiple times by the STM, and might be called later in any enclosing atomic block.

Transforms the value stored in the Ref by multiplying it.

'''Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.'''

Transforms the value stored in the Ref by incrementing it.

'''Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.'''

Transforms the value stored in the Ref by decrementing it.

'''Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.'''

Transforms the value stored in ref by performing a division on it, throwing away the remainder if division is not exact for instances of type A. The careful reader will note that division is actually provided by Fractional[A] or Integral[A], it is not defined on Numeric[A]. To avoid compile-time ambiguity this method accepts a Numeric[A] and assumes that it can be converted at runtime into either a Fractional[A] or an Integral[A].

'''Note: Implementations may choose to ignore the provided Numeric[A] instance if A is a primitive type.'''

Atomically replaces the value ''v'' stored in the Ref with the first element of the 2-tuple returned by f(''v''), returning the second element.

Performs an atomic read of the value in ref. If an atomic block is active (see Txn.findCurrent) then the read will be performed as part of the transaction, otherwise it will act as if it was performed inside a new atomic block. Equivalent to get.

Blocks until f(get) is true, in a manner consistent with the current context. Requires that the predicate be safe to reevaluate, and that f(x) == f(y) if x == y.

v.await(f) is equivalent to

  atomic { implicit t =>
    if (!f(v.get)) retry
  }

If you want to wait for a predicate that involves more than one Ref then use retry directly.

Performs an atomic read; equivalent to apply().

Acts like ref.getWith(f) if there is an active transaction, otherwise just returns f(get).

Acts like ref.relaxedGet(equiv) if there is an active transaction, otherwise just returns get.

Performs an atomic write; equivalent to update(v).

Blocks until f(get) is true and returns true, or returns false if the condition does not become true within within the specified timeout.

v.tryAwait(timeout)(f) is equivalent to

  atomic { implicit t =>
    f(v.get) || { retryFor(timeout) ; false }
  }

Performs an atomic write and returns true, or returns false. The STM implementation may choose to return false to reduce (not necessarily avoid) blocking. If no other threads are performing any transactional or atomic accesses then this method will succeed.

Performs an atomic write of the value in ref. If an atomic block is active (see Txn.findCurrent) then the write will be performed as part of the transaction, otherwise it will act as if it was performed inside a new atomic block. Equivalent to set(v).