de.sciss.lucre.confluent

Sys

trait Sys[S <: Sys[S]] extends stm.Sys[S]

This is analogous to a ConfluentLike trait. Since there is only one system in LucreConfluent, it was decided to just name it confluent.Sys.

S

the implementing system

Linear Supertypes
stm.Sys[S], Closeable, AutoCloseable, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Sys
  2. Sys
  3. Closeable
  4. AutoCloseable
  5. AnyRef
  6. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. final type Acc = Access[S]

    Definition Classes
    Sys → Sys
  2. abstract type Context <: AnyRef

    Definition Classes
    Sys
  3. abstract type D <: DurableLike[D]

  4. abstract type I <: InMemoryLike[I]

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

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

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

    Definition Classes
    Sys → Sys

Abstract Value Members

  1. abstract def close(): Unit

    Definition Classes
    Sys → Closeable → AutoCloseable
  2. abstract 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.

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

  4. abstract def durable: D

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

  6. abstract def inMemory: I

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

    Definition Classes
    Sys
  8. abstract def newCursor(init: Access[S])(implicit tx: S.Tx): Cursor[S, D]

  9. abstract def newCursor()(implicit tx: S.Tx): Cursor[S, D]

  10. abstract def readCursor(in: DataInput)(implicit tx: S.Tx): Cursor[S, D]

  11. abstract def readPath(in: DataInput): Access[S]

  12. abstract def root[A](init: (S.Tx) ⇒ A)(implicit serializer: Serializer[S.Tx, S.Acc, A]): stm.Source[S.Tx, A]

    Definition Classes
    Sys
  13. abstract def rootWithDurable[A, B](confluent: (S.Tx) ⇒ A)(durable: (D.Tx) ⇒ B)(implicit aSer: Serializer[S.Tx, Access[S], A], bSer: Serializer[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

    confluent

    a function that provides the initial confluent data (if the database is fresh)

    durable

    a function that provides the initial ephemeral data (if the database is fresh)

    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.

Concrete Value Members

  1. final def !=(arg0: AnyRef): Boolean

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

    Definition Classes
    Any
  3. final def ##(): Int

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

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

    Definition Classes
    Any
  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  7. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  8. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  10. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  11. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  12. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  13. final def isInstanceOf[T0]: Boolean

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

    Definition Classes
    AnyRef
  15. final def notify(): Unit

    Definition Classes
    AnyRef
  16. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  17. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  18. def toString(): String

    Definition Classes
    AnyRef → Any
  19. final def wait(): Unit

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from stm.Sys[S]

Inherited from Closeable

Inherited from AutoCloseable

Inherited from AnyRef

Inherited from Any

Ungrouped