Packages

object Var

Note: There is a Java-friendly API for this object: com.twitter.util.Vars.

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Var
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

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. def apply[T](init: T, e: Event[T]): Var[T]

    Constructs a Var from an initial value plus an event stream of changes.

    Constructs a Var from an initial value plus an event stream of changes. Note that this eagerly subscribes to the event stream; it is unsubscribed whenever the returned Var is collected.

  5. def apply[T](init: T): Var[T] with Updatable[T] with Extractable[T]

    Create a new, updatable Var with an initial value.

    Create a new, updatable Var with an initial value. We call such Vars independent -- derived Vars being dependent on these.

  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def async[T](empty: T)(update: (Updatable[T]) ⇒ Closable): Var[T]

    Create a new Var whose values are provided asynchronously by update.

    Create a new Var whose values are provided asynchronously by update. The returned Var is dormant until it is observed: update is called by-need. Such observations are also reference counted so that simultaneous observations do not result in multiple invocations of update. When the last observer stops observing, the com.twitter.util.Closable returned from update is closed. Subsequent observations result in a new call to update.

    empty is used to fill the returned Var until update has provided a value. The first observation of the returned Var is synchronous with the call to update--it is guaranteed the the opportunity to fill the Var before the observer sees any value at all.

    Updates from update are ignored after the returned com.twitter.util.Closable is closed.

  8. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  9. def collect[T <: AnyRef](vars: List[Var[T]]): Var[List[T]]

    Collect a List of Vars into a new Var of List.

    Collect a List of Vars into a new Var of List.

    vars

    a java.util.List of Vars

    returns

    a Var[java.util.List[A]] containing the collected values from vars.

  10. def collect[T, CC[X] <: Traversable[X]](vars: CC[Var[T]])(implicit arg0: ClassTag[T], newBuilder: CanBuildFrom[CC[T], T, CC[T]]): Var[CC[T]]

    Collect a collection of Vars into a Var of collection.

    Collect a collection of Vars into a Var of collection. Var.collect can result in a stack overflow if called with a large sequence. Var.collectIndependent breaks composition with respect to update propagation. That is, collectIndependent can fail to correctly update interdependent vars, but is safe for independent vars.

    // Example of difference between collect and collectIndependent:
    val v1 = Var(1)
    val v2 = v1.map(_*2)
    val vCollect = Var.collect(Seq(v1, v2)).map { case Seq(a, b) => (a, b) }
    val vCollectIndependent = Var.collectIndependent(Seq(v1, v2)).map { case Seq(a, b) => (a, b) }
    val refCollect = new AtomicReference[Seq[(Int, Int)]]
    vCollect.changes.build.register(Witness(refCollect))
    val refCollectIndependent = new AtomicReference[Seq[(Int, Int)]]
    vCollectIndependent.changes.build.register(Witness(refCollectIndependent))
    v1() = 2
    // refCollect == Vector((1,2), (2,4))
    // refCollectIndependent == Vector((1,2), (2,2), (2,4))
  11. def collectIndependent[T, CC[X] <: Traversable[X]](vars: CC[Var[T]])(implicit arg0: ClassTag[T], newBuilder: CanBuildFrom[CC[T], T, CC[T]]): Var[CC[T]]

    Collect a collection of Vars into a Var of collection.

    Collect a collection of Vars into a Var of collection. Var.collect can result in a stack overflow if called with a large sequence. Var.collectIndependent breaks composition with respect to update propagation. That is, collectIndependent can fail to correctly update interdependent vars, but is safe for independent vars.

    // Example of difference between collect and collectIndependent:
    val v1 = Var(1)
    val v2 = v1.map(_*2)
    val vCollect = Var.collect(Seq(v1, v2)).map { case Seq(a, b) => (a, b) }
    val vCollectIndependent = Var.collectIndependent(Seq(v1, v2)).map { case Seq(a, b) => (a, b) }
    val refCollect = new AtomicReference[Seq[(Int, Int)]]
    vCollect.changes.build.register(Witness(refCollect))
    val refCollectIndependent = new AtomicReference[Seq[(Int, Int)]]
    vCollectIndependent.changes.build.register(Witness(refCollectIndependent))
    v1() = 2
    // refCollect == Vector((1,2), (2,4))
    // refCollectIndependent == Vector((1,2), (2,2), (2,4))
  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  14. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  20. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  21. def patch[CC[_], T](diffs: Event[Diff[CC, T]])(implicit arg0: Diffable[CC]): Var[CC[T]]

    Patch reconstructs a Var based on observing the incremental changes presented in the underlying Diffs.

    Patch reconstructs a Var based on observing the incremental changes presented in the underlying Diffs.

    Note that this eagerly subscribes to the event stream; it is unsubscribed whenever the returned Var is collected.

  22. def sample[T](v: Var[T]): T

    Sample the current value of this Var.

    Sample the current value of this Var. Note that this may lead to surprising results for lazily defined Vars: the act of observing a Var may be kick off a process to populate it; the value returned from sample may then reflect an intermediate value.

  23. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  24. def toString(): String
    Definition Classes
    AnyRef → Any
  25. def value[T](v: T): Var[T]

    Create a new, constant, v-valued Var.

  26. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  27. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  28. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  29. object Sampled

Inherited from AnyRef

Inherited from Any

Ungrouped