Lucre-confluent/de.sciss.lucre.confluent.impl/Mixin

Mixin

trait Mixin[Tx <: Txn[Tx]] extends ConfluentLike[Tx] with IndexMapHandler[Tx] with PartialMapHandler[Tx] with Mixin[Tx]
trait Mixin[Tx]
trait ReactionMap[Tx]
trait IndexMapHandler[Tx]
trait ConfluentLike[Tx]
trait Sys
trait Sys
trait Base
trait Closeable
trait AutoCloseable
class Object
trait Matchable
class Any
Mixin[Tx]

Type members

Inherited types

type D <: Txn[D]
Inherited from
Sys
type I <: Txn[I]
Inherited from
Sys
type T = Tx
Inherited from
ConfluentLike

Value members

Abstract methods

def durableTx(tx: T): D
protected
def storeFactory: Factory
protected
def wrapRegular(dtx: D, inputAccess: Access[T], retroactive: Boolean, cursorCache: Cache[T], systemTimeNanos: Long): T
protected
def wrapRoot(peer: InTxn): T

Concrete methods

def close(): Unit
final
def createTxn(dtx: D, inputAccess: Access[T], retroactive: Boolean, cursorCache: Cache[T], systemTimeNanos: Long): T
def cursorRoot[A, B](init: T => A)(result: T => A => B)(implicit format: TFormat[T, A]): (Ref[T, A], B)
def debugPrintIndex(index: Access[T])(implicit tx: T): String
final
def flushRegular(meldInfo: MeldInfo[T], newVersion: Boolean, caches: IndexedSeq[Cache[T]])(implicit tx: T): Unit
final
def flushRoot(meldInfo: MeldInfo[T], newVersion: Boolean, caches: IndexedSeq[Cache[T]])(implicit tx: T): Unit
final
def getIndexTreeTerm(term: Long)(implicit tx: T): Long
def isAncestor(term1: Long, term2: Long)(implicit tx: T): Boolean
final
def newCursor()(implicit tx: T): Cursor[T, D]
final
def newCursor(init: Access[T])(implicit tx: T): Cursor[T, D]
final
def newIdValue()(implicit tx: T): Int
final override
def newIndexMap[A](tx: T, rootTerm: Long, rootValue: A)(implicit index: Access[Tx], format: ConstFormat[A]): IndexMap[T, A]
Definition Classes
final
def newPartialMap[A](rootValue: A)(implicit tx: T, format: ConstFormat[A]): IndexMap[T, A]
final
def newVersionId(implicit tx: T): Long
def numRecords(implicit tx: T): Int
def numUserRecords(implicit tx: T): Int
final
def readCursor(in: DataInput)(implicit tx: T): Cursor[T, D]
final override
def readIndexMap[A](in: DataInput, tx: T)(implicit index: Access[Tx], format: ConstFormat[A]): IndexMap[T, A]
Definition Classes
final
def readPartialMap[A](in: DataInput)(implicit tx: T, format: ConstFormat[A]): IndexMap[T, A]
final
def readPath(in: DataInput): Access[T]
final
def readTreeVertex(tree: Tree[D, Long], term: Long)(implicit tx: D): (Vertex[D, Long], Int)
final
def root[A](init: T => A)(implicit format: TFormat[T, A]): Ref[T, A]
final
def rootJoin[A](init: T => A)(implicit itx: TxnLike, format: TFormat[T, A]): Ref[T, A]
final
def rootWithDurable[A, B](confInt: T => A)(durInit: D => B)(implicit aFmt: TFormat[T, A], bFmt: TFormat[D, B]): (Source[T, A], B)
override
def toString: String
Definition Classes
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.

final
def versionUntil(access: Access[T], timeStamp: Long)(implicit tx: T): Access[T]

Inherited methods

final
def addEventReaction[A](event: Event[Tx, A], observer: Observer[Tx, A])(implicit tx: Tx): Boolean
Inherited from
Mixin
def durable: DurableLike[D]
Inherited from
Sys
def getEventReactions[A](event: Event[Tx, A])(implicit tx: Tx): List[Observer[Tx, A]]
Inherited from
Mixin
def hasEventReactions[A](event: Event[Tx, A])(implicit tx: Tx): Boolean
Inherited from
Mixin
def inMemory: InMemoryLike[I]
Inherited from
Sys
def reactionMap: ReactionMap[Tx]
Inherited from
Mixin
def removeEventReaction[A](event: Event[Tx, Any], observer: Observer[Tx, A])(implicit tx: Tx): Boolean
Inherited from
Mixin

Concrete fields

final protected
val eventMap: IdentMap[T, Map[Int, List[Observer[T, _]]]]
final
val fullCache: Durable[T, Int, DurablePersistentMap[T, Int]]
final
val store: DataStore