RegularTxnMixin

abstract def cursorCache: Cache[S.Tx]

implicit abstract def durable: Sys.D.Tx

abstract def inMemory: Sys.I.Tx

abstract def inputAccess: Access[S]

abstract def isRetroactive: Boolean

abstract def peer: InTxn

abstract val system: S

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var _context: S.Context

final def addDirtyCache(map: Cache[S.Tx]): Unit

final def addDirtyLocalCache(map: Cache[S.Tx]): Unit

A local cache is one which is re-created upon application restart.

final def addInputVersion(path: Access[S]): Unit

def afterCommit(code: ⇒ Unit): Unit

final def alloc(pid: Identifier[S]): Identifier[S]

final def allocPartial(pid: Identifier[S]): Identifier[S]

final def asInstanceOf[T0]: T0

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

final 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 flushCaches(meldInfo: MeldInfo[S], newVersion: Boolean, caches: IndexedSeq[Cache[S.Tx]]): Unit

final def fullCache: Durable[S, Int, DurablePersistentMap[S, Int]]

final def getClass(): Class[_]

final def getNonTxn[A](id: Identifier[S])(implicit ser: ImmutableSerializer[A]): A

final def getTxn[A](id: Identifier[S])(implicit ser: Serializer[S.Tx, Access[S], A]): A

def hashCode(): Int

final def info: Modifiable

final def isInstanceOf[T0]: Boolean

final def meldInfo: MeldInfo[S]

final var message: String

(Possibly empty) message describing the associated transaction.

final def ne(arg0: AnyRef): Boolean

final def newBooleanVar(pid: Identifier[S], init: Boolean): Var[S, Boolean]

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

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

The confluent handle is enhanced with the meld method.

final def newID(): Identifier[S]

final def newInMemoryIDMap[A]: IdentifierMap[Identifier[S], S.Tx, A]

final def newIntVar(pid: Identifier[S], init: Int): Var[S, Int]

final def newLongVar(pid: Identifier[S], init: Long): Var[S, Long]

final def newVar[A](pid: Identifier[S], init: A)(implicit ser: Serializer[S.Tx, Access[S], A]): Var[S, A]

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

final def notify(): Unit

final def notifyAll(): Unit

final def putNonTxn[A](id: Identifier[S], value: A)(implicit ser: ImmutableSerializer[A]): Unit

final def putTxn[A](id: Identifier[S], value: A)(implicit ser: Serializer[S.Tx, Access[S], A]): Unit

final def readBooleanVar(pid: Identifier[S], in: DataInput): Var[S, Boolean]

final def readID(in: DataInput, acc: Access[S]): Identifier[S]

final def readIntVar(pid: Identifier[S], in: DataInput): Var[S, Int]

final def readLongVar(pid: Identifier[S], in: DataInput): Var[S, Long]

final def readPartialSource(in: DataInput, pid: Identifier[S]): Identifier[S]

final def readSource(in: DataInput, pid: Identifier[S]): Identifier[S]

final def readTreeVertexLevel(term: Long): Int

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

final def removeFromCache(id: Identifier[S]): Unit

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

final val timeStamp: Long

System time stamp of the associated transaction.

def toString(): String

final def use[A](context: S.Context)(fun: ⇒ A): A

final def wait(): Unit

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

final def wait(arg0: Long): Unit