trait Mixin[S <: Sys[S]] extends Sys[S] with IndexMapHandler[S] with PartialMapHandler[S] with event.impl.ReactionMapImpl.Mixin[S]
- Self Type
- Mixin[S] with S
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- Mixin
- Mixin
- ReactionMap
- PartialMapHandler
- IndexMapHandler
- Sys
- Sys
- Base
- Closeable
- AutoCloseable
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Type Members
- final type Acc = Access[S]
- Definition Classes
- Sys → Base
- abstract type D <: DurableLike[(Mixin.this)#D]
- Definition Classes
- Sys
- abstract type I <: InMemoryLike[(Mixin.this)#I]
- Definition Classes
- Sys → Sys → Base
- final type Id = Identifier[S]
- Definition Classes
- Sys → Base
- abstract type Tx <: Txn[S]
- Definition Classes
- Sys → Sys → Base
- final type Var[A] = confluent.Var[S, A]
- Definition Classes
- Sys → Base
Abstract Value Members
- abstract def durable: (Mixin.this)#D
- Definition Classes
- Sys
- abstract def durableTx(tx: S.Tx): Sys.D.Tx
- abstract def inMemory: (Mixin.this)#I
- Definition Classes
- Base
- abstract def inMemoryTx(tx: S.Tx): Sys.I.Tx
- Definition Classes
- Base
- abstract def storeFactory: Factory
- Attributes
- protected
- abstract def wrapRegular(dtx: Sys.D.Tx, inputAccess: Access[S], retroactive: Boolean, cursorCache: Cache[S.Tx], systemTimeNanos: Long): S.Tx
- Attributes
- protected
- abstract def wrapRoot(peer: InTxn): S.Tx
- Attributes
- protected
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → 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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def close(): Unit
- Definition Classes
- Mixin → Base → Closeable → AutoCloseable
- final def createTxn(dtx: Sys.D.Tx, inputAccess: Access[S], retroactive: Boolean, cursorCache: Cache[S.Tx], systemTimeNanos: Long): 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)
Initializes the data structure, by either reading an existing entry or generating the root entry with the
initfunction.Initializes the data structure, by either reading an existing entry or generating the root entry with the
initfunction. The method than allows the execution of another function within the same transaction, passing it the data structure root of typeA. 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.
- def debugPrintIndex(index: Access[S])(implicit tx: S.Tx): String
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): 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[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
- 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[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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
- Annotations
- @native()
- final def indexMap: IndexMapHandler[S]
- 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]
- 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]
- 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
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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]
- 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]
- 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.SourcebecauseD#AccisUnitand does not need refresh.
- final val store: DataStore
- 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.
- final def versionUntil(access: Access[S], timeStamp: Long)(implicit tx: S.Tx): Access[S]
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()