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
- Alphabetic
- By Inheritance
- Sys
- Sys
- Base
- Closeable
- AutoCloseable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
final
type
Acc = Access[S]
The path access type for objects if they carry a temporal trace.
- abstract type D <: DurableLike[D]
- abstract type I <: InMemoryLike[I]
-
final
type
Id = Identifier[S]
The identifier type of the system.
The identifier type of the system. This is an opaque type about which the user only knows that it uniquely identifies and object (or an object along with its access path in the confluent case). It is thus valid to assume that two objects are equal if their identifiers are equal.
-
abstract
type
Tx <: Txn[S]
The transaction type of the system.
-
final
type
Var[A] = confluent.Var[S, A]
The variable type of the system.
Abstract Value Members
-
abstract
def
close(): Unit
Closes the underlying database (if the system is durable).
Closes the underlying database (if the system is durable). The STM cannot be used beyond this call. An in-memory system should have a no-op implementation.
- Definition Classes
- Base → Closeable → AutoCloseable
-
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
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.
- abstract def debugPrintIndex(index: Access[S])(implicit tx: S.Tx): String
- abstract def durable: D
- abstract def durableTx(tx: S.Tx): D.Tx
-
abstract
def
inMemory: I
- Definition Classes
- Base
-
abstract
def
inMemoryTx(tx: S.Tx): I.Tx
- Definition Classes
- Base
- abstract def newCursor(init: Access[S])(implicit tx: S.Tx): Cursor[S, D]
- abstract def newCursor()(implicit tx: S.Tx): Cursor[S, D]
- abstract def readCursor(in: DataInput)(implicit tx: S.Tx): Cursor[S, D]
- abstract def readPath(in: DataInput): Access[S]
-
abstract
def
root[A](init: (S.Tx) ⇒ A)(implicit serializer: Serializer[S.Tx, S.Acc, A]): stm.Source[S.Tx, A]
Reads the root object representing the stored data structure, or provides a newly initialized one via the
initargument, if no root has been stored yet.Reads the root object representing the stored data structure, or provides a newly initialized one via the
initargument, if no root has been stored yet.- Definition Classes
- Sys
-
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.SourcebecauseD#AccisUnitand does not need refresh.
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
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
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
- @native() @throws( ... )