Type Members

1.  trait Adjunct extends Writable
2.  trait AnyExec extends Exec[AnyExec]
3.  abstract final class AnyTxn extends Txn[AnyTxn]
4.  trait Artifact[T <: Txn[T]] extends Expr[T, Value]

   An artifact is a file on an external storage.

5.  trait ArtifactLocation[T <: Txn[T]] extends Expr[T, Value]

   An artifact location is a directory on an external storage.

6.  trait ArtifactPlatform extends AnyRef
7.  trait Base 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.

8.  trait BiGroup[T <: Txn[T], A] extends Obj[T] with Publisher[T, Update[T, A, BiGroup[T, A]]]
9.  trait BiPin[T <: Txn[T], A] extends Obj[T] with Publisher[T, Update[T, A, BiPin[T, A]]]
10.  trait BooleanObj[T <: Txn[T]] extends Expr[T, Boolean]
11.  trait Caching extends AnyRef

    A marker trait for events that maintain a cache.

    A marker trait for events that maintain a cache. Events mixing in this trait are guaranteed to participate in the pullUpdate phase, even if no live observer is attached to them.

12.  trait Confluent extends ConfluentLike[lucre.Confluent.Txn]
13.  trait ConfluentLike[Tx <: lucre.confluent.Txn[Tx]] extends lucre.confluent.Sys
14.  trait Copy[In <: Txn[In], Out <: Txn[Out]] extends AnyRef
15.  trait Cursor[T <: Exec[T]] extends AnyRef
16.  trait DataStore extends Closeable
17.  trait Disposable[-T] extends AnyRef
18.  trait DoubleObj[T <: Txn[T]] extends Expr[T, Double]
19.  trait DoubleVector[T <: Txn[T]] extends Expr[T, IndexedSeq[Double]]
20.  trait Durable extends DurableLike[lucre.Durable.Txn]
21.  trait DurableLike[Tx <: lucre.DurableLike.Txn[Tx]] extends Sys with Cursor[Tx]
22.  trait Elem[T <: Txn[T]] extends Form[T] with Writable with Disposable[T] with Publisher[T, Any]

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

23.  trait Event[T <: Txn[T], +A] extends EventLike[T, A] with Writable

    Event is not sealed in order to allow you define traits inheriting from it, while the concrete implementations should extend either of Event.Constant or Event.Node (which itself is sealed and split into Event.Invariant and Event.Mutating.

24.  trait EventLike[T <: Txn[T], +A] extends Observable[T, A]
25.  trait Exec[T <: Exec[T]] extends AnyRef
26.  trait Expr[T <: Txn[T], +A] extends ExprLike[T, A] with Obj[T] with Publisher[T, Change[A]]

    An expression is a computation that reduces to a single value of type A.

    An expression is a computation that reduces to a single value of type A. Expressions can be understood as data-flow variables. When a tree is composed, a change in the root of the tree propagates through to the leaves in the form of an emitted Change event that carries the old and new value (according to the particular node of the tree).

    Basic expression types are Expr.Const - it simply wraps a constant value and thus will never change or fire an event - and Expr.Var which can be thought of as a mutable variable carrying a peer expression. When the variable assignment changes, the expression currently held is evaluated and propagated as an event. Intermediate nodes or expressions might modify the value, such as a binary operator (e.g., an integer expression that sums two input integer expressions).

27.  trait ExprLike[T <: Exec[T], +A] extends Form[T]

    This is the current compromise for unifying Ex/IExpr and Expr in terms of their usability through runWith vs.

    This is the current compromise for unifying Ex/IExpr and Expr in terms of their usability through runWith vs. obj.attr.

28.  trait Folder[T <: Txn[T]] extends Modifiable[T, Obj[T]]
29.  trait Form[T] extends AnyRef

    Any form parametrized in a Base system.

    Any form parametrized in a Base system. This trait allows us to pattern match against heterogeneous objects whose only common feature is that they share the system.

30.  trait IChangeEvent[T <: Exec[T], +A] extends IEvent[T, Change[A]]
31.  trait IChangePublisher[T <: Exec[T], +A] extends IPublisher[T, Change[A]]
32.  trait IEvent[T <: Exec[T], +A] extends Observable[T, A]

    In-memory (non-serializable) event.

33.  trait IExpr[T <: Exec[T], +A] extends ExprLike[T, A] with IChangePublisher[T, A] with Disposable[T]
34.  trait IPublisher[T <: Exec[T], +A] extends AnyRef
35.  trait IPull[T <: Exec[T]] extends AnyRef
36.  trait ITargets[T <: Exec[T]] extends AnyRef

    Interconnection management for in-memory events.

    Interconnection management for in-memory events. A centralized instance that combines the functionality of Targets with ReactionMap.

37.  trait Ident[T <: Exec[T]] extends Disposable[T] with Writable
38.  trait IdentMap[T <: Exec[T], A] extends Disposable[T]

    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.

    T

    the underlying system's transaction type

    A

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

39.  trait Identified[T <: Exec[T]] extends AnyRef
40.  trait InMemory extends InMemoryLike[lucre.InMemory.Txn]

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

41.  trait InMemoryLike[Tx <: lucre.InMemoryLike.Txn[Tx]] extends Sys with Cursor[Tx]
42.  trait IntObj[T <: Txn[T]] extends Expr[T, Int]
43.  trait IntVector[T <: Txn[T]] extends Expr[T, IndexedSeq[Int]]
44.  trait ListObj[T <: Txn[T], A] extends Obj[T] with Publisher[T, Update[T, A, ListObj[T, 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

45.  trait LongObj[T <: Txn[T]] extends Expr[T, Long]
46.  trait MapObj[T <: Txn[T], K, Repr[~ <: Txn[~]] <: Form[~]] extends MapObjLike[T, K, Repr[T]] with Obj[T] with Publisher[T, Update[T, K, Repr]]
47.  trait MapObjLike[T <: Exec[T], K, V] extends Disposable[T]
48.  trait Mutable[T <: Exec[T]] extends Identified[T] with Writable with Disposable[T]
49.  trait Obj[T <: Txn[T]] extends Elem[T] with Mutable[T]

    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.

50.  trait Observable[Tx, +A] extends AnyRef
51.  trait Observer[T <: Exec[T], -A] extends Disposable[T]
52.  trait Plain extends Base with Cursor[Plain] with Exec[Plain]
53.  trait ProductWithAdjuncts extends Product
54.  trait Publisher[T <: Txn[T], +A] extends AnyRef
55.  trait Pull[T <: Txn[T]] extends AnyRef
56.  trait Random[-T] extends AnyRef

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

57.  trait RandomObj[T <: Exec[T]] extends Random[T] with Mutable[T]

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

58.  trait ReactionMap[T <: Txn[T]] extends AnyRef
59.  trait Ref[-T, A] extends Source[T, A] with Sink[T, A]
60.  trait RefMap[T <: Exec[T], K, V] extends AnyRef
61.  trait RefSet[T <: Exec[T], A] extends AnyRef
62.  trait Sink[-T, -A] extends AnyRef
63.  trait Source[-T, +A] extends AnyRef
64.  trait SpanLikeObj[T <: Txn[T]] extends Expr[T, SpanLike]
65.  trait SpanObj[T <: Txn[T]] extends Expr[T, Span]
66.  trait StringObj[T <: Txn[T]] extends Expr[T, String]
67.  trait Sys extends Base

    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.).

68.  trait TOrdered[-Tx, -A] extends AnyRef
69.  trait TOrdering[-Tx, A] extends AnyRef
70.  trait Txn[T <: Txn[T]] extends Exec[T] with TxnLike
71.  trait TxnLike extends AnyRef

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

72.  trait Var[-T, A] extends Ref[T, A] with Writable with Disposable[T]
73.  trait Workspace[T <: Txn[T]] extends Disposable[T]