Observable

Value Members

1. final def !=(arg0: AnyRef): Boolean

   Definition Classes

   AnyRef

2. final def !=(arg0: Any): Boolean

   Definition Classes

   Any

3. final def ##(): Int

   Definition Classes

   AnyRef → Any

4. final def ==(arg0: AnyRef): Boolean

   Definition Classes

   AnyRef

5. final def ==(arg0: Any): Boolean

   Definition Classes

   Any

6. implicit def FutureIsObservable[T](future: Future[T])(implicit scheduler: Scheduler): Observable[T]

   Implicit conversion from Future to Observable.

7. final def asInstanceOf[T0]: T0

   Definition Classes

   Any

8. def clone(): AnyRef

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

9. def concat[T](sources: Observable[T]*)(implicit scheduler: Scheduler): Observable[T]

   Concatenates the given list of observables into a single observable.

10. def continuous[T](elem: T)(implicit scheduler: Scheduler): Observable[T]

    Creates an Observable that continuously emits the given item

11. def create[T](f: (Observer[T]) ⇒ Unit)(implicit scheduler: Scheduler): Observable[T]

    Observable constructor.

    Observable constructor. To be used for implementing new Observables and operators.

12. def empty[A](implicit scheduler: Scheduler): Observable[A]

13. final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

14. def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

15. def error(ex: Throwable)(implicit scheduler: Scheduler): Observable[Nothing]

    Creates an Observable that emits an error.

16. def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

17. def flatten[T](sources: Observable[T]*)(implicit scheduler: Scheduler): Observable[T]

    Concatenates the given list of observables into a single observable.

18. def fromIterable[T](iterable: Iterable[T])(implicit scheduler: Scheduler): Observable[T]

    Creates an Observable that emits the elements of the given iterable.

    Creates an Observable that emits the elements of the given iterable. Prefer fromSequence for immutable collections that can be efficiently decomposed as head/tail.

19. def fromIterable[T](iterable: Iterable[T])(implicit scheduler: Scheduler): Observable[T]

    Creates an Observable that emits the elements of the given iterable.

    Creates an Observable that emits the elements of the given iterable. Prefer fromSequence for immutable collections that can be efficiently decomposed as head/tail.

20. def fromSequence[T](seq: Seq[T])(implicit scheduler: Scheduler): Observable[T]

    Creates an Observable that emits the elements of the given sequence

21. final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

22. def hashCode(): Int

    Definition Classes

    AnyRef → Any

23. def interval(initialDelay: FiniteDuration, period: FiniteDuration)(implicit scheduler: Scheduler): Observable[Long]

    Creates an Observable that emits auto-incremented natural numbers with a fixed delay, starting from number 1.

    Creates an Observable that emits auto-incremented natural numbers with a fixed delay, starting from number 1.

    initialDelay

    the initial delay to wait before the first emitted number

    period

    the delay between two subsequent events

    scheduler

    the execution context in which onNext will get called

24. def interval(period: FiniteDuration)(implicit scheduler: Scheduler): Observable[Long]

    Creates an Observable that emits auto-incremented natural numbers with a fixed delay, starting from number 1.

    Creates an Observable that emits auto-incremented natural numbers with a fixed delay, starting from number 1.

    period

    the delay between two emitted events

    scheduler

    the execution context in which onNext will get called

25. final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

26. def merge[T](sources: Observable[T]*)(implicit scheduler: Scheduler): Observable[T]

    Merges the given list of observables into a single observable.

27. final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

28. def never(implicit scheduler: Scheduler): Observable[Nothing]

    Creates an Observable that doesn't emit anything and that never completes.

29. final def notify(): Unit

    Definition Classes

    AnyRef

30. final def notifyAll(): Unit

    Definition Classes

    AnyRef

31. def range(from: Int, until: Int, step: Int = 1)(implicit scheduler: Scheduler): Observable[Int]

    Creates an Observable that emits items in the given range.

    Creates an Observable that emits items in the given range.

    from

    the range start

    until

    the range end

    step

    increment step, either positive or negative

32. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

33. def toString(): String

    Definition Classes

    AnyRef → Any

34. def unit[A](elem: A)(implicit scheduler: Scheduler): Observable[A]

    Creates an Observable that only emits the given a

35. final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

36. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

37. final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

38. def zip[T1, T2, T3, T4](obs1: Observable[T1], obs2: Observable[T2], obs3: Observable[T3], obs4: Observable[T4]): Observable[(T1, T2, T3, T4)]

    Creates a new Observable from three observables, by emitting elements combined in tuples of 4 elements.

    Creates a new Observable from three observables, by emitting elements combined in tuples of 4 elements. If one of the Observable emits fewer events than the others, then the rest of the unpaired events are ignored.

39. def zip[T1, T2, T3](obs1: Observable[T1], obs2: Observable[T2], obs3: Observable[T3]): Observable[(T1, T2, T3)]

    Creates a new Observable from three observables, by emitting elements combined in tuples of 3 elements.

    Creates a new Observable from three observables, by emitting elements combined in tuples of 3 elements. If one of the Observable emits fewer events than the others, then the rest of the unpaired events are ignored.

40. def zip[T1, T2](obs1: Observable[T1], obs2: Observable[T2]): Observable[(T1, T2)]

    Creates a new Observable from two observables, by emitting elements combined in pairs.

    Creates a new Observable from two observables, by emitting elements combined in pairs. If one of the Observable emits fewer events than the other, then the rest of the unpaired events are ignored.