Mixin

Type Members

final type Acc = Access[S]

Definition Classes
Sys → Sys
abstract type Context <: AnyRef

Definition Classes
Sys
abstract type D <: DurableLike[(Mixin.this)#D]

Definition Classes
Sys
abstract type I <: InMemoryLike[(Mixin.this)#I]

Definition Classes
Sys → Sys
final type ID = Identifier[S]

Definition Classes
Sys → Sys
abstract type Tx <: Txn[S]

Definition Classes
Sys → Sys
final type Var[A] = confluent.Var[S, A]

Definition Classes
Sys → Sys

Abstract Value Members

abstract def durable: (Mixin.this)#D

Definition Classes
Sys
abstract def durableTx(tx: S.Tx): Sys.D.Tx

Definition Classes
Mixin → Sys
abstract def inMemory: (Mixin.this)#I

Definition Classes
Sys
abstract def inMemoryTx(tx: S.Tx): Sys.I.Tx

Definition Classes
Sys
abstract def storeFactory: Factory

Attributes
protected
abstract def wrapRegular(dtx: Sys.D.Tx, inputAccess: Access[S], retroactive: Boolean, cursorCache: Cache[S.Tx]): S.Tx

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

Attributes
protected

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def addEventReaction[A](event: Event[S, A], observer: Observer[S, A])(implicit tx: S.Tx): Boolean

Definition Classes
Mixin → ReactionMap
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit

Definition Classes
Mixin → Sys → Closeable → AutoCloseable
final def createTxn(dtx: Sys.D.Tx, inputAccess: Access[S], retroactive: Boolean, cursorCache: Cache[S.Tx]): S.Tx

Definition Classes
Mixin → Sys
def cursorRoot[A, B](init: (S.Tx) ⇒ A)(result: (S.Tx) ⇒ (A) ⇒ B)(implicit serializer: Serializer[S.Tx, Access[S], A]): (confluent.Var[S, A], B)

Initializes the data structure, by either reading an existing entry or generating the root entry with the init function.
Initializes the data structure, by either reading an existing entry or generating the root entry with the init function. The method than allows the execution of another function within the same transaction, passing it the data structure root of type A. This is typically used to generate access mechanisms, such as extracting a cursor from the data structure, or instantiating a new cursor. The method then returns both the access point to the data structure and the result of the second function.
A
type of data structure
B
type of result from the second function. typically this is an stm.Cursor[S]
init
a function to initialize the data structure (if the database is fresh)
result
a function to process the data structure
serializer
a serializer to read or write the data structure
returns
the access to the data structure along with the result of the second function.

Definition Classes
Mixin → Sys
def debugPrintIndex(index: Access[S])(implicit tx: S.Tx): String

Definition Classes
Mixin → Sys
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final val eventMap: IdentifierMap[Identifier[S], S.Tx, Map[Int, List[Observer[S, _]]]]

Attributes
protected
Definition Classes
Mixin → Mixin
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flushRegular(meldInfo: MeldInfo[S], newVersion: Boolean, caches: IndexedSeq[Cache[S.Tx]])(implicit tx: S.Tx): Unit

Definition Classes
Mixin → Sys
final def flushRoot(meldInfo: MeldInfo[S], newVersion: Boolean, caches: IndexedSeq[Cache[S.Tx]])(implicit tx: S.Tx): Unit

Definition Classes
Mixin → Sys
final val fullCache: Durable[S, Int, Store[S, Int]]

Definition Classes
Mixin → Sys
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getEventReactions[A](event: Event[S, A])(implicit tx: S.Tx): List[Observer[S, A]]

Definition Classes
Mixin → ReactionMap
final def getIndexTreeTerm(term: Long)(implicit tx: S.Tx): Long

Definition Classes
Mixin → PartialMapHandler
def hasEventReactions[A](event: Event[S, A])(implicit tx: S.Tx): Boolean

Definition Classes
Mixin → ReactionMap
def hashCode(): Int

Definition Classes
AnyRef → Any
final def indexMap: IndexMapHandler[S]

Definition Classes
Mixin → Sys
def isAncestor(term1: Long, term2: Long)(implicit tx: S.Tx): Boolean

Definition Classes
Mixin → IndexMapHandler
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def newCursor(init: Access[S])(implicit tx: S.Tx): Cursor[S, (Mixin.this)#D]

Definition Classes
Mixin → Sys
final def newCursor()(implicit tx: S.Tx): Cursor[S, (Mixin.this)#D]

Definition Classes
Mixin → Sys
final def newIDValue()(implicit tx: S.Tx): Int

Definition Classes
Mixin → Sys
final def newIndexMap[A](index: Access[S], rootTerm: Long, rootValue: A)(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

Definition Classes
Mixin → IndexMapHandler
final def newPartialMap[A](rootValue: A)(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

Definition Classes
Mixin → PartialMapHandler
final def newVersionID(implicit tx: S.Tx): Long

Definition Classes
Mixin → Sys
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numRecords(implicit tx: S.Tx): Int
def numUserRecords(implicit tx: S.Tx): Int
def reactionMap: ReactionMap[S]

Definition Classes
Mixin
final def readCursor(in: DataInput)(implicit tx: S.Tx): Cursor[S, (Mixin.this)#D]

Definition Classes
Mixin → Sys
final def readIndexMap[A](in: DataInput, index: Access[S])(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

Definition Classes
Mixin → IndexMapHandler
final def readPartialMap[A](in: DataInput)(implicit tx: S.Tx, serializer: ImmutableSerializer[A]): IndexMap[S, A]

Definition Classes
Mixin → PartialMapHandler
final def readPath(in: DataInput): Access[S]

Definition Classes
Mixin → Sys
final def readTreeVertex(tree: Tree[(Mixin.this)#D, Long], term: Long)(implicit tx: Sys.D.Tx): (Vertex[(Mixin.this)#D, Long], Int)
def removeEventReaction[A](event: Event[S, Any], observer: Observer[S, A])(implicit tx: S.Tx): Boolean

Definition Classes
Mixin → ReactionMap
final def root[A](init: (S.Tx) ⇒ A)(implicit serializer: Serializer[S.Tx, Access[S], A]): confluent.Var[S, A]

Definition Classes
Mixin → Sys
final def rootJoin[A](init: (S.Tx) ⇒ A)(implicit itx: TxnLike, serializer: Serializer[S.Tx, Access[S], A]): confluent.Var[S, A]

Definition Classes
Mixin → Sys
final def rootWithDurable[A, B](confInt: (S.Tx) ⇒ A)(durInit: (Sys.D.Tx) ⇒ B)(implicit aSer: Serializer[S.Tx, Access[S], A], bSer: Serializer[Sys.D.Tx, Unit, B]): (stm.Source[S.Tx, A], B)

Initializes the data structure both with a confluently persisted and an ephemeral-durable value.
Initializes the data structure both with a confluently persisted and an ephemeral-durable value.
A
type of confluent data structure
B
type of ephemeral data structure
aSer
a serializer to read or write the confluent data structure
bSer
a serializer to read or write the ephemeral data structure
returns
a tuple consisting of a handle to the confluent structure and the ephemeral datum. The ephemeral datum, although written to disk, does not require an stm.Source because D#Acc is Unit and does not need refresh.

Definition Classes
Mixin → Sys
final val store: DataStore

Definition Classes
Mixin → Sys
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Mixin → AnyRef → Any
final def versionInfo(term: Long)(implicit tx: TxnLike): VersionInfo

Retrieves the version information for a given version term.
Retrieves the version information for a given version term.

Definition Classes
Mixin → Sys
final def versionUntil(access: Access[S], timeStamp: Long)(implicit tx: S.Tx): Access[S]

Definition Classes
Mixin → Sys
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

trait Mixin[S <: Sys[S]] extends Sys[S] with IndexMapHandler[S] with PartialMapHandler[S] with event.impl.ReactionMapImpl.Mixin[S]

Type Members

final type Acc = Access[S]

abstract type Context <: AnyRef

abstract type D <: DurableLike[(Mixin.this)#D]

abstract type I <: InMemoryLike[(Mixin.this)#I]

final type ID = Identifier[S]

abstract type Tx <: Txn[S]

final type Var[A] = confluent.Var[S, A]

Abstract Value Members

abstract def durable: (Mixin.this)#D

abstract def durableTx(tx: S.Tx): Sys.D.Tx

abstract def inMemory: (Mixin.this)#I

abstract def inMemoryTx(tx: S.Tx): Sys.I.Tx

abstract def storeFactory: Factory

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

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

Concrete Value Members

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 addEventReaction[A](event: Event[S, A], observer: Observer[S, A])(implicit tx: S.Tx): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def close(): Unit

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

def cursorRoot[A, B](init: (S.Tx) ⇒ A)(result: (S.Tx) ⇒ (A) ⇒ B)(implicit serializer: Serializer[S.Tx, Access[S], A]): (confluent.Var[S, A], B)

def debugPrintIndex(index: Access[S])(implicit tx: S.Tx): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final val eventMap: IdentifierMap[Identifier[S], S.Tx, Map[Int, List[Observer[S, _]]]]

def finalize(): Unit

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

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

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

final def getClass(): Class[_]

def getEventReactions[A](event: Event[S, A])(implicit tx: S.Tx): List[Observer[S, A]]

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

def hasEventReactions[A](event: Event[S, A])(implicit tx: S.Tx): Boolean

def hashCode(): Int

final def indexMap: IndexMapHandler[S]

def isAncestor(term1: Long, term2: Long)(implicit tx: S.Tx): Boolean

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def newCursor(init: Access[S])(implicit tx: S.Tx): Cursor[S, (Mixin.this)#D]

final def newCursor()(implicit tx: S.Tx): Cursor[S, (Mixin.this)#D]

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

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

final def newPartialMap[A](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

def reactionMap: ReactionMap[S]

final def readCursor(in: DataInput)(implicit tx: S.Tx): Cursor[S, (Mixin.this)#D]

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

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

final def readPath(in: DataInput): Access[S]

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

def removeEventReaction[A](event: Event[S, Any], observer: Observer[S, A])(implicit tx: S.Tx): Boolean

final def root[A](init: (S.Tx) ⇒ A)(implicit serializer: Serializer[S.Tx, Access[S], A]): confluent.Var[S, A]

final def rootJoin[A](init: (S.Tx) ⇒ A)(implicit itx: TxnLike, serializer: Serializer[S.Tx, Access[S], A]): confluent.Var[S, A]

final def rootWithDurable[A, B](confInt: (S.Tx) ⇒ A)(durInit: (Sys.D.Tx) ⇒ B)(implicit aSer: Serializer[S.Tx, Access[S], A], bSer: Serializer[Sys.D.Tx, Unit, B]): (stm.Source[S.Tx, A], B)

final val store: DataStore

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

def toString(): String

final def versionInfo(term: Long)(implicit tx: TxnLike): VersionInfo

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from event.impl.ReactionMapImpl.Mixin[S]

Inherited from ReactionMap[S]

Inherited from PartialMapHandler[S]

Inherited from IndexMapHandler[S]

Inherited from Sys[S]