Mixin

abstract def durable: (Mixin.this)#D

abstract def inMemory: (Mixin.this)#I

abstract def storeFactory: DataStoreFactory[DataStore]

abstract def wrapRegular(dtx: Sys.D.Tx, inputAccess: Sys.Acc[S], cursorCache: Cache[S.Tx]): S.Tx

abstract def wrapRoot(peer: InTxn): S.Tx

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 asInstanceOf[T0]: T0

def clone(): AnyRef

def close(): Unit

final def createTxn(dtx: Sys.D.Tx, inputAccess: Sys.Acc[S], cursorCache: Cache[S.Tx]): S.Tx

def cursorRoot[A, B](init: (S.Tx) ⇒ A)(result: (S.Tx) ⇒ (A) ⇒ B)(implicit serializer: Serializer[S.Tx, Sys.Acc[S], A]): (Sys.Entry[S, A], B)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def flushRegular(meldInfo: MeldInfo[S], caches: IndexedSeq[Cache[S.Tx]])(implicit tx: S.Tx): Unit

final def flushRoot(meldInfo: MeldInfo[S], caches: IndexedSeq[Cache[S.Tx]])(implicit tx: S.Tx): Unit

final val fullCache: Durable[S, Int, Store[S, Int]]

final def getClass(): Class[_]

final def getIndexTreeTerm(term: Long)(implicit tx: S.Tx): Long

def hashCode(): Int

final def indexMap: IndexMapHandler[S]

def isAncestor(index: Sys.Acc[S], term1: Long, term2: Long)(implicit tx: S.Tx): Boolean

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def newCursor(init: Sys.Acc[S])(implicit tx: S.Tx): Cursor[S]

final def newIDValue()(implicit tx: S.Tx): Int

final def newIndexMap[A](index: Sys.Acc[S], rootTerm: Long, rootValue: A)(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

final def newPartialMap[A](access: Sys.Acc[S], rootTerm: Long, rootValue: A)(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

final def newVersionID(implicit tx: S.Tx): Long

final def notify(): Unit

final def notifyAll(): Unit

def numRecords(implicit tx: S.Tx): Int

def numUserRecords(implicit tx: S.Tx): Int

final val partialCache: Partial[S, Int, Store[S, Int]]

final def readCursor(in: DataInput, access: Sys.Acc[S])(implicit tx: S.Tx): Cursor[S]

final def readIndexMap[A](in: DataInput, index: Sys.Acc[S])(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

final def readPartialMap[A](access: Sys.Acc[S], in: DataInput)(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

final def readPath(in: DataInput): Sys.Acc[S]

final def readTreeVertex(tree: Tree[(Mixin.this)#D, Long], index: Sys.Acc[S], term: Long)(implicit tx: Sys.D.Tx): (Vertex[(Mixin.this)#D, Long], Int)

final def root[A](init: (S.Tx) ⇒ A)(implicit serializer: Serializer[S.Tx, Sys.Acc[S], A]): Sys.Entry[S, A]

final val store: DataStore

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

def toString(): String

final def versionInfo(term: Long)(implicit tx: S.Tx): VersionInfo

Retrieves the version information for a given version term.

final def versionUntil(access: Sys.Acc[S], timeStamp: Long)(implicit tx: S.Tx): Sys.Acc[S]

final def wait(): Unit

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

final def wait(arg0: Long): Unit