p

reactify

package reactify

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

Type Members

  1. class AbstractState [T] extends State[T]
  2. trait ChangeObserver [T] extends AnyRef

    Convenience functionality for classic change management referencing the old value along with the new value.

    Convenience functionality for classic change management referencing the old value along with the new value.

    T

    the type of changes

  3. trait Channel [T] extends Observable[T]
  4. class Dep [T, V] extends StateChannel[T]

    Dep is very much like a Val, but is also a Channel.

    Dep is very much like a Val, but is also a Channel. The basic purpose is to represent a value dependent upon another variable. An example of this might be if you are representing a position left and you also wanted to represent right as well (which would be left + width). These two variables are dependent upon each other and don't fit well as Vars. An example usage might be:

    val left: Var[Double] = Var(0.0) val width: Var[Double] = Var(0.0) val right: Dep[Double, Double] = Dep(left, width)

    If an instance is submissive it removes adjustment from being part of the mutation dependency. For example: in the above scenario if you set width to 100.0 and right to 125.0 then left will be 25.0. Now, what should happen if you change width to 50.0? Should left change to 75.0 (submissive = false) or should right change to 75.0 (submissive = true)?

  5. trait DepConnector [T, V] extends AnyRef
  6. trait DirtyState [T] extends AbstractState[T]
  7. class Invocation extends AnyRef
  8. sealed trait InvocationType extends AnyRef
  9. implicit class ListStateChannel [T] extends AnyRef

    Syntactic sugar for mutating collections in a StateChannel

  10. trait Observable [T] extends AnyRef

    Observable, as the name suggests, observes values being fired against it.

    Observable, as the name suggests, observes values being fired against it. This is the core functionality of Reactify and provides the infrastructure used by Channel, Val, Var, Prop, and Dep.

    T

    the type of value this Observable will receive

  11. trait Observer [T] extends Ordered[Observer[T]]
  12. trait State [T] extends Observable[T]
  13. trait StateChannel [T] extends State[T] with Channel[T]
  14. class Transaction extends AnyRef
  15. class TransactionApplier [T] extends AnyRef
  16. case class TransformResult [T] extends Product with Serializable
  17. trait TransformableChannel [T] extends Channel[T]

    TransformableChannel extends from Channel to provide transforming capabilities before observers are invoked.

    TransformableChannel extends from Channel to provide transforming capabilities before observers are invoked.

    T

    the channel's type

  18. case class TransformableValue [T](value: T) extends Product with Serializable
  19. trait TransformingObserver [T] extends Ordered[TransformingObserver[T]]
  20. class Trigger extends AnyRef

    Trigger works very similar to Channel except it doesn't receive anything.

    Trigger works very similar to Channel except it doesn't receive anything. Observers are attached like on an Observable, but they receive no arguments.

  21. class Val [T] extends AbstractState[T]

    Val, as the name suggests, is like a Scala val.

    Val, as the name suggests, is like a Scala val. This represents an immutable value that is set in the first place and then not modified. However, since the value set may be built from Observables, the generated value may change over time as its dependencies are modified. This class is Observable and will only fire changes if the underlying value is derived from one or more Observables.

    T

    the type of value retained by this State

  22. class Var [T] extends Val[T] with StateChannel[T]

    Var, as the name suggests, is very similar to a Scala var.

    Var, as the name suggests, is very similar to a Scala var. The value is defined during instantiation, but may be modified later. The value may be a static value, or may be a derived value depending on multiple Observables. If Observables make up the value they will be monitored and events fired on this Observable as the value changes.

    T

    the type of value this channel receives

  23. implicit class VectorStateChannel [T] extends AnyRef
  24. class WrappedObservable [T] extends Observable[T]

Value Members

  1. implicit val doubleConnector: DepConnector[Double, Double]
  2. implicit def function2Observer[T](f: (T) ⇒ Unit): Observer[T]
  3. implicit val intConnector: DepConnector[Int, Int]
  4. implicit def state2Value[T](p: State[T]): T

    Converts a State[T] to T implicitly.

    Converts a State[T] to T implicitly. This is useful for DSL type-based operations like 5 + stateVar.

  5. object ChangeObserver
  6. object Channel
  7. object Dep
  8. object Invocation
  9. object InvocationType
  10. object Observable
  11. object Observer
  12. object Transaction
  13. object TransformableChannel
  14. object TransformingObserver
  15. object Trigger
  16. object Val
  17. object Var

Inherited from AnyRef

Inherited from Any

Ungrouped