event

Type Members

1. sealed trait Bang[S <: Sys[S]] extends Trigger[S, Unit, Bang[S]] with Node[S]

   A simple event implementation for an imperative (trigger) event that fires "bangs" or impulses, using the Unit type as event type parameter.

2. final case class Change[A](before: A, now: A) extends Product with Serializable

   Value based events fire instances of Change which provides the value before and after modification.

3. trait Compound[S <: Sys[S], D <: Decl[S, Repr], Repr <: Compound[S, D, Repr]] extends Node[S]

4. trait Decl[S <: stm.Sys[S], Impl <: Node[S]] extends AnyRef

   A trait to be mixed in by event dispatching companion objects.

5. trait Dummy[S <: stm.Sys[S], +A, +Repr] extends EventLike[S, A, Repr]

6. trait Durable extends DurableLike[Durable]

7. trait DurableLike[S <: DurableLike[S]] extends stm.DurableLike[S] with Sys[S]

8. trait Event[S <: stm.Sys[S], +A, +Repr] extends EventLike[S, A, Repr] with VirtualNodeSelector[S]

   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.

9. trait EventLike[S <: stm.Sys[S], +A, +Repr] extends AnyRef

10. trait EventLikeSerializer[S <: Sys[S], Repr <: Writable] extends Reader[S, Repr] with io.Serializer[event.EventLikeSerializer.S.Tx, event.EventLikeSerializer.S.Acc, Repr]

    A trait to serialize events which can be both constants and immutable nodes.

11. trait InMemory extends InMemoryLike[InMemory] with Sys[InMemory]

12. trait InvariantEvent[S <: stm.Sys[S], +A, +Repr] extends InvariantSelector[S] with Event[S, A, Repr]

13. trait InvariantSelector[S <: stm.Sys[S]] extends VirtualNodeSelector[S]

14. trait MutatingEvent[S <: stm.Sys[S], +A, +Repr] extends MutatingSelector[S] with Event[S, A, Repr]

15. trait MutatingSelector[S <: stm.Sys[S]] extends VirtualNodeSelector[S]

16. trait Node[S <: stm.Sys[S]] extends VirtualNode[S]

17. trait NodeSerializer[S <: Sys[S], Repr <: Node[S]] extends Reader[S, Repr] with io.Serializer[event.NodeSerializer.S.Tx, event.NodeSerializer.S.Acc, Repr]

18. sealed trait Observer[S <: stm.Sys[S], -A, +Repr] extends Disposable[event.Observer.S.Tx]

    Observer instances are returned by the observe method of classes implementing Observable.

19. final case class ObserverKey[S <: stm.Sys[S]] extends Selector[S] with Product with Serializable

    Instances of ObserverKey are provided by methods in Txn, when a live Observer is registered.

20. sealed trait Pull[S <: stm.Sys[S]] extends AnyRef

21. sealed trait Push[S <: stm.Sys[S]] extends Pull[S]

22. type Reaction = () ⇒ () ⇒ Unit

23. trait ReactionMap[S <: stm.Sys[S]] extends AnyRef

24. sealed trait Reactor[S <: stm.Sys[S]] extends Mutable[event.Reactor.S.ID, event.Reactor.S.Tx]

    The Reactor trait encompasses the possible targets (dependents) of an event.

25. trait Reader[S <: stm.Sys[S], +Repr] extends AnyRef

26. sealed trait Selector[S <: stm.Sys[S]] extends AnyRef

27. type Serializer[S <: stm.Sys[S], Repr] = Reader[S, Repr] with io.Serializer[event.Serializer.S.Tx, event.Serializer.S.Acc, Repr]

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

29. sealed trait Targets[S <: stm.Sys[S]] extends Reactor[S]

    An abstract trait unifying invariant and mutating targets.

30. trait Trigger[S <: stm.Sys[S], A, +Repr] extends Event[S, A, Repr]

    A Trigger event is one which can be publically fired.

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

32. trait Var[S <: stm.Sys[S], A] extends Sink[event.Var.S.Tx, A] with Writable with Disposable[event.Var.S.Tx]

33. sealed trait VirtualNode[S <: stm.Sys[S]] extends Reactor[S]

34. sealed trait VirtualNodeSelector[S <: stm.Sys[S]] extends Selector[S]