Atomically executes body as part of a commit barrier, ensuring that if the transaction commits, all actions performed by all members of the commit barrier appear to occur simultaneously. If the transaction commits then the value v returned by body is returned as Right(v). If this member is cancelled then this method returns Left(c), where c describes the first cause passed to the cancel method. If this member is not cancelled but the transaction is rolled back without the possibility of retry, then this method throws an exception the same as any other atomic block (see TxnExecutor.apply).

It is not allowed to chain orAtomic onto this form of atomic, but you can accomplish the same effect with a nested atomic block:

member.atomic { implicit txn =>
  atomic { implicit txn =>
    ... first alternative
  } orAtomic { implicit txn =>
    ... second alternative
  }
}

In the current version of ScalaSTM this method may only be used if there is no enclosing transaction; an STM implementation may throw IllegalStateException if there is already an active transaction on this thread. This restriction might be relaxed in the future if there is a use case for it (and a semantics for how it should work).

Removes this member from the commit barrier, and causes any pending or future calls to this.atomic to return a Left. If the commit barrier has already committed successfully this method throws IllegalStateException. It is safe to call this method multiple times.

Returns the TxnExecutor that will be used by atomic. This is initialized during construction to the default TxnExecutor (returned by scala.concurrent.stm.atomic).