Blocks until f(get) is true, in a manner consistent with the current
context.
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.
a predicate that is safe to evaluate multiple times.
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 == get) { set(after); true } else false), but may be more
efficient, especially if there is no enclosing atomic block.
a value to compare against the ref's contents using the
value's == method.
a value to store if before was equal to the previous
contents.
true if before was equal to the previous value of the viewed
Ref, false otherwise.
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.
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.
a value to compare against the ref's contents using
reference identity equality (eq).
a value to store if before was eq to the previous
contents.
true if before was eq to the previous value of the viewed
Ref, false otherwise.
Performs an atomic read; equivalent to apply().
Performs an atomic read; equivalent to apply().
the value of the Ref as observed by the current context.
Atomically replaces the value v stored in the Ref with
f(v), returning the old value.
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.
a function that is safe to call multiple times, and safe to call later during any enclosing atomic block.
the previous value of the viewed Ref.
Acts like ref.getWith(f) if there is an active transaction, otherwise
just returns f(get).
Acts like ref.getWith(f) if there is an active transaction, otherwise
just returns f(get).
an idempotent function.
the result of applying f to the value contained in ref.
Returns a Ref that accesses the same memory location as this view.
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.
a Ref that accesses the same memory location as this view.
Acts like ref.relaxedGet(equiv) if there is an active transaction,
otherwise just returns get.
Acts like ref.relaxedGet(equiv) if there is an active transaction,
otherwise just returns get.
an equivalence function that returns true if a transaction that observed the first argument will still complete correctly, where the second argument is the actual value that should have been observed.
a value of the Ref, not necessary consistent with the rest of
the reads performed by the active transaction, if any.
Performs an atomic write; equivalent to update(v).
Performs an atomic write; equivalent to update(v).
Works like set(v), but returns the old value.
Works like set(v), but returns the old value. This is an
atomic swap, equivalent to atomically performing a get
followed by set(v).
the previous value held by ref.
Atomically replaces the value v stored in the Ref with
f(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.
a function that is safe to call multiple times, and safe to call later during the enclosing atomic block, if any.
Atomically replaces the value v stored in the Ref with
f(v), returning the new value.
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.
a function that is safe to call multiple times, and safe to call later during any enclosing atomic block.
the new value of the viewed Ref.
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.
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.
a partial function that is safe to call multiple times, and safe to call later during any enclosing atomic block.
pf.isDefinedAt(''v''), where ''v'' is the element held by
this Ref on entry.
Blocks until f(get) is true and returns true, or returns false if
the condition does not become true within within the specified timeout.
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 }
}
the maximum amount of time to wait, in units of unit.
the units in which the timeout is measured, defaulting to milliseconds.
a predicate that is safe to evaluate multiple times.
true if the predicate was satisfied, false if the wait timed out.
Performs an atomic write and returns true, or returns 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.
Transforms the value stored in the Ref by multiplying it.
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.
the quantity by which to multiple the value of ref.
Transforms the value stored in the Ref by incrementing it.
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.
the quantity by which to increment the value of ref.
Transforms the value stored in the Ref by decrementing it.
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.
the quantity by which to decrement the value of ref.
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.
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.
the quantity by which to divide the value of ref.
Performs an atomic read of the value in ref.
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.
the value of the Ref as observed by the current context.
Performs an atomic write of the value in ref.
Performs an atomic write of the value in ref. If an atomic block is
active (see Txn.current) 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).
Ref.Viewprovides access to the contents of aRefwithout requiring that an implicitInTxnbe available. When called from within the dynamic scope of a transaction,View's methods operate as part of that transaction. When there is no transaction activeView's methods are still atomic, but only for the duration of the method call.A mental model of
Viewis thatview.foo(args)acts likeatomic { implicit t => view.ref.foo(args) }.