TxnMixin

abstract def inMemory: Sys.I.Tx

abstract def peer: InTxn

Every transaction has a plain Scala-STM transaction as a peer.

abstract val system: S

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def afterCommit(code: ⇒ Unit): Unit

Registers a thunk to be executed after the transaction successfully committed.

final def asInstanceOf[T0]: T0

def attrMap(obj: Obj[S]): AttrMap[S]

def beforeCommit(fun: (S.Tx) ⇒ Unit): Unit

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def newBooleanVar(id: Id[S], init: Boolean): Var[S.Tx, Boolean]

final def newCachedIntVar(init: Int): Var[S.Tx, Int]

final def newCachedLongVar(init: Long): Var[S.Tx, Long]

final def newCachedVar[A](init: A)(implicit ser: Serializer[S.Tx, Unit, A]): Var[S.Tx, A]

final def newHandle[A](value: A)(implicit serializer: Serializer[S.Tx, Unit, A]): Source[S.Tx, A]

final def newId(): Id[S]

final def newInMemoryIdMap[A]: IdentifierMap[Id[S], S.Tx, A]

def newInMemoryMap[K, V]: RefMap[S, K, V]

def newInMemorySet[A]: RefSet[S, A]

final def newIntVar(id: Id[S], init: Int): Var[S.Tx, Int]

final def newLongVar(id: Id[S], init: Long): Var[S.Tx, Long]

def newRef[A](init: A): Ref[S.Tx, A]

final def newVar[A](id: Id[S], init: A)(implicit ser: Serializer[S.Tx, Unit, A]): Var[S.Tx, A]

final def newVarArray[A](size: Int): Array[Var[S.Tx, A]]

final def notify(): Unit

final def notifyAll(): Unit

final def readBooleanVar(pid: Id[S], in: DataInput): Var[S.Tx, Boolean]

final def readCachedIntVar(in: DataInput): Var[S.Tx, Int]

final def readCachedLongVar(in: DataInput): Var[S.Tx, Long]

final def readCachedVar[A](in: DataInput)(implicit ser: Serializer[S.Tx, Unit, A]): Var[S.Tx, A]

final def readId(in: DataInput, acc: Unit): Id[S]

final def readIntVar(pid: Id[S], in: DataInput): Var[S.Tx, Int]

final def readLongVar(pid: Id[S], in: DataInput): Var[S.Tx, Long]

final def readVar[A](pid: Id[S], in: DataInput)(implicit ser: Serializer[S.Tx, Unit, A]): Var[S.Tx, A]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit