TxnMixin

abstract def flushCaches(meld: MeldInfo[S], newVersion: Boolean, caches: IndexedSeq[Cache[S.Tx]]): Unit

abstract def inputAccess: Acc[S]

abstract def isRetroactive: Boolean

abstract def peer: InTxn

abstract def system: S

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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: Acc[S]): Unit

def afterCommit(code: ⇒ Unit): Unit

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

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

final def asInstanceOf[T0]: T0

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 fullCache: Durable[S, Int, DurablePersistentMap[S, Int]]

final def getClass(): Class[_]

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

final def getPartial[A](id: ID[S])(implicit ser: Serializer[S.Tx, Acc[S], A]): A

final def getTxn[A](id: ID[S])(implicit ser: Serializer[S.Tx, Acc[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: ID[S], init: Boolean): Var[S, Boolean]

final def newDurableIDMap[A](implicit serializer: Serializer[S.Tx, Acc[S], A]): IdentifierMap[ID[S], S.Tx, A]

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

final def newID(): ID[S]

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

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

final def newLocalVar[A](init: (S.Tx) ⇒ A): LocalVar[S.Tx, A]

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

final def newPartialID(): ID[S]

final def newPartialVar[A](pid: ID[S], init: A)(implicit ser: Serializer[S.Tx, Acc[S], A]): Var[S, A]

final def newVar[A](pid: ID[S], init: A)(implicit ser: Serializer[S.Tx, Acc[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 partialCache: Partial[S, Int, DurablePersistentMap[S, Int]]

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

final def putPartial[A](id: ID[S], value: A)(implicit ser: Serializer[S.Tx, Acc[S], A]): Unit

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

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

final def readDurableIDMap[A](in: DataInput)(implicit serializer: Serializer[S.Tx, Acc[S], A]): IdentifierMap[ID[S], S.Tx, A]

final def readID(in: DataInput, acc: Acc[S]): ID[S]

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

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

final def readPartialID(in: DataInput, acc: Acc[S]): ID[S]

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

final def readPartialVar[A](pid: ID[S], in: DataInput)(implicit ser: Serializer[S.Tx, Acc[S], A]): Var[S, A]

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

final def readTreeVertexLevel(term: Long): Int

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

final def removeDurableIDMap[A](map: IdentifierMap[ID[S], S.Tx, A]): Unit

final def removeFromCache(id: ID[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 wait(): Unit

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

final def wait(arg0: Long): Unit