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

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

Inherited methods

final def addEventReaction[A](event: Event[Tx, A], observer: Observer[Tx, A])(tx: Tx): Boolean
Inherited from
Mixin
def durable: DurableLike[D]
Inherited from
Sys
def getEventReactions[A](event: Event[Tx, A])(tx: Tx): List[Observer[Tx, A]]
Inherited from
Mixin
def hasEventReactions[A](event: Event[Tx, A])(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])(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