Type Members

1.  trait Base[S <: Base[S]] extends Closeable

   The Base trait is a pre-stage to stm.Sys, without introducing peer STM transactions.

   The Base trait is a pre-stage to stm.Sys, without introducing peer STM transactions. It can thus be used to build purely imperative non-transactional systems.

   S

   the representation type of the system

2.  trait Copy[In <: Sys[In], Out <: Sys[Out]] extends AnyRef
3.  trait Copy1[In <: Sys[In], Out <: Sys[Out]] extends Copy[In, Out]

   Temporary interface extension until we can break binary compatibility.

4.  trait Cursor[S <: Base[S]] extends AnyRef
5.  trait DataStore extends Closeable
6.  trait Disposable[-Tx] extends AnyRef
7.  trait DummySerializerFactory[S <: Base[S]] extends AnyRef
8.  trait Durable extends DurableLike[Durable]
9.  trait DurableLike[S <: DurableLike[S]] extends Sys[S] with Cursor[S]
10.  trait Elem[S <: Sys[S]] extends Writable with Disposable[stm.Elem.S.Tx] with Publisher[S, Any]

    An Elem is any type that is globally registered via Elem.addType and can be de-serialized through Elem.read.

11.  trait Executor[S <: Base[S]] extends AnyRef
12.  trait Folder[S <: Sys[S]] extends Modifiable[S, Obj[S]]
13.  trait Identifiable[+Id] extends AnyRef
14.  trait Identifier[-Tx] extends Disposable[Tx] with Writable
15.  trait IdentifierMap[Id, -Tx, A] extends Disposable[Tx]

    An identifier map is basically a transactional map whose keys are system identifiers.

    An identifier map is basically a transactional map whose keys are system identifiers. However, there are two important aspects: First, the map is always ephemeral (but might be still durable!), even for a confluently persistent system. Second, for systems whose identifiers constitute temporal traces (confluently persistent system), lookup (via get, contains etc.) finds _any_ value stored for the current version or any older version. That is to say, in a confluently persistent system, it looks up the most recent entry for the key. It is therefore a useful tool to map system entities to ephemeral live views.

    Id

    the underlying system's identifier type

    Tx

    the underlying system's transaction type

    A

    the values stored at the keys. Unit can be used if only set functionality is needed.

16.  trait InMemory extends InMemoryLike[InMemory]

    A thin in-memory (non-durable) wrapper around Scala-STM.

17.  trait InMemoryLike[S <: InMemoryLike[S]] extends Sys[S] with Cursor[S]
18.  trait List[S <: Sys[S], A] extends Obj[S] with Publisher[S, Update[S, A]]

    An observable linked list with fast head and last operations.

    An observable linked list with fast head and last operations. This is the read-only layer, see List.Modifiable for a mutable list.

    The list will report insertions and deletions.

    A

    the element type of the list

19.  trait Mutable[+Id, -Tx] extends Identifiable[Id] with Writable with Disposable[Tx]
20.  trait NoBase extends Base[NoBase]
21.  trait NoSys extends Sys[NoSys]
22.  trait Obj[S <: Sys[S]] extends Elem[S] with Mutable[stm.Obj.S.Id, stm.Obj.S.Tx]

    An Obj is a type of element that has an S#Id identifier and an attribute map.

    An Obj is a type of element that has an S#Id identifier and an attribute map. It can be the origin of event dispatch.

23.  trait Plain extends Base[Plain] with Cursor[Plain] with Executor[Plain]
24.  trait Random[-Tx] extends AnyRef

    A transactional pseudo-random number generator which behaves numerically like java.util.Random.

25.  trait Ref[-Tx, A] extends Sink[Tx, A] with Source[Tx, A]
26.  trait RefMap[S <: Base[S], K, V] extends AnyRef
27.  trait RefSet[S <: Base[S], A] extends AnyRef
28.  trait Sink[-Tx, -A] extends AnyRef

    A sink is a transactional write access to a value

29.  trait Source[-Tx, +A] extends AnyRef

    A source is a transactional read access to a value

30.  trait Sys[S <: Sys[S]] extends Base[S]

    A system in LucreSTM describes a particular mode of representing values in time and of persisting values to disk.

    A system in LucreSTM describes a particular mode of representing values in time and of persisting values to disk. The Sys trait contains types for variables, identifiers, access paths, and transactions which are unique to each system (such as ephemeral in-memory, confluently persistent etc.).

    S

    the representation type of the system

31.  trait Txn[S <: Sys[S]] extends Executor[S] with TxnLike
32.  trait TxnLike extends AnyRef

    This is a minimal trait for any type of transactions that wrap an underlying Scala-STM transaction.

33.  trait TxnRandom[S <: Base[S]] extends Random[stm.TxnRandom.S.Tx] with Mutable[stm.TxnRandom.S.Id, stm.TxnRandom.S.Tx]

    A transactional pseudo-random number generator which behaves numerically like java.util.Random.

34.  trait Var[-Tx, A] extends Ref[Tx, A] with Writable with Disposable[Tx]

    A transactional variable is an identifiable cell allowing the reading and writing of values

35.  trait Workspace[S <: Sys[S]] extends Disposable[stm.Workspace.S.Tx]