Packages

trait Event[+T] extends AnyRef

Events are instantaneous values, defined only at particular instants in time (cf. Vars, which are defined at all times). It is possible to view Events as the discrete counterpart to Var's continuous nature.

Events are observed by registering Witnesses to which the Event's values are notified.

Note: There is a Java-friendly API for this trait: com.twitter.util.AbstractEvent.

Self Type
Event[T]
Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Event
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def register(s: Witness[T]): Closable

    Register the given Witness to this Event.

    Register the given Witness to this Event. Witnesses are notified of new values until it is deregistered by the returned Closable.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def build[U >: T, That](implicit cbf: CanBuild[U, That]): Event[That]

    Progressively build a collection of events using the passed-in builder.

    Progressively build a collection of events using the passed-in builder. A value containing the current version of the collection is notified for each incoming event.

  6. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  7. def collect[U](f: PartialFunction[T, U]): Event[U]

    Build a new Event by applying the given function to each value observed.

    Build a new Event by applying the given function to each value observed. Event values for which the partial function f does not apply are dropped; other values are transformed by f.

  8. def dedup: Event[T]

    Builds a new Event by keeping only the Events where the previous and current values are not == to each other.

  9. def dedupWith(eq: (T, T) ⇒ Boolean): Event[T]

    Build a new Event by keeping only those Event values where the equality predicate eq applied to the current and new values does not match.

  10. def diff[CC[_], U](implicit arg0: Diffable[CC], toCC: <:<[T, CC[U]]): Event[Diff[CC, U]]

    The Event that stores the difference between successive updates to the parent event.

    The Event that stores the difference between successive updates to the parent event. This can be used to perform incremental computation on large data structures.

  11. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  12. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  13. def filter(p: (T) ⇒ Boolean): Event[T]

    Build a new Event by keeping only those Event values that match the predicate p.

  14. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. def foldLeft[U](z: U)(f: (U, T) ⇒ U): Event[U]

    Build a new Event by incrementally accumulating over events, starting with value z.

    Build a new Event by incrementally accumulating over events, starting with value z. Each intermediate aggregate is notified to the derived event.

  16. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  18. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  19. def joinLast[U](other: Event[U]): Event[(T, U)]

    Join two events into a new Event which notifies a tuple of the last value in each underlying event.

  20. def map[U](f: (T) ⇒ U): Event[U]

    Build a new Event by transforming each new event value with f.

  21. def merge[U >: T](other: Event[U]): Event[U]

    Merge two events; the resulting event interleaves events from this and other.

  22. def mergeMap[U](f: (T) ⇒ Event[U]): Event[U]

    The Event which merges the events resulting from f applied to each element in this Event.

  23. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  25. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. def patch[CC[_], U](implicit arg0: Diffable[CC], ev: <:<[T, Diff[CC, U]]): Event[CC[U]]

    Patch up an Event of differences (like those produced by Event.diff) into an Event that reflects the current version of a data structure.

    Patch up an Event of differences (like those produced by Event.diff) into an Event that reflects the current version of a data structure. That is: (event: Event[CC[T]]).diff.patch is equivalent to event

  27. final def respond(s: (T) ⇒ Unit): Closable

    Observe this event with function s.

    Observe this event with function s. Equivalent to register(Witness(s)).

  28. def select[U](other: Event[U]): Event[Either[T, U]]

    Merge two Events of different types.

  29. def sliding(n: Int): Event[Seq[T]]

    Build a new Event representing a sliding window of at-most n.

    Build a new Event representing a sliding window of at-most n. Each event notified by the parent are added to a queue of size at-most n. This queue is in turn notified to register of the returned event.

  30. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  31. def take(howmany: Int): Event[T]

    An event which consists of the first howmany values in the parent Event.

  32. def toFuture(): Future[T]

    A Future which is satisfied by the first value observed.

  33. def toString(): String
    Definition Classes
    AnyRef → Any
  34. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  35. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  36. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  37. def zip[U](other: Event[U]): Event[(T, U)]

    Merge two event streams in lock-step, combining corresponding event values.

    Merge two event streams in lock-step, combining corresponding event values.

    Note

    This can be dangerous! Since the implementation needs to queue outstanding Event-values from the slower producer, if one Event outpaces another, this queue can grow in an unbounded fashion.

Inherited from AnyRef

Inherited from Any

Ungrouped