Packages

object Schedule extends Serializable

Linear Supertypes
Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Schedule
  2. Serializable
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. sealed trait Decision extends AnyRef
  2. final case class Driver[+State, -Env, -In, +Out](next: (In) => ZIO[Env, None.type, Out], last: IO[NoSuchElementException, Out], reset: UIO[Unit], state: UIO[State]) extends Product with Serializable
  3. sealed abstract class Interval extends AnyRef

    An Interval represents an interval of time.

    An Interval represents an interval of time. Intervals can encompass all time, or no time at all.

  4. sealed abstract case class Intervals extends Product with Serializable

    Intervals represents a set of intervals.

  5. type WithState[State0, -Env, -In0, +Out0] = Schedule[Env, In0, Out0] { type State = State0 }

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 clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  6. def collectAll[A](implicit trace: Trace): WithState[(Unit, Chunk[A]), Any, A, Chunk[A]]

    A schedule that recurs anywhere, collecting all inputs into a list.

  7. def collectUntil[A](f: (A) => Boolean)(implicit trace: Trace): WithState[(Unit, Chunk[A]), Any, A, Chunk[A]]

    A schedule that recurs until the condition f fails, collecting all inputs into a list.

  8. def collectUntilZIO[Env, A](f: (A) => URIO[Env, Boolean])(implicit trace: Trace): WithState[(Unit, Chunk[A]), Env, A, Chunk[A]]

    A schedule that recurs until the effectful condition f fails, collecting all inputs into a list.

  9. def collectWhile[A](f: (A) => Boolean)(implicit trace: Trace): WithState[(Unit, Chunk[A]), Any, A, Chunk[A]]

    A schedule that recurs as long as the condition f holds, collecting all inputs into a list.

  10. def collectWhileZIO[Env, A](f: (A) => URIO[Env, Boolean])(implicit trace: Trace): WithState[(Unit, Chunk[A]), Env, A, Chunk[A]]

    A schedule that recurs as long as the effectful condition holds, collecting all inputs into a list.

  11. val count: WithState[Long, Any, Any, Long]

    A schedule that always recurs, which counts the number of recurrences.

  12. def dayOfMonth(day: Int)(implicit trace: Trace): WithState[(OffsetDateTime, Long), Any, Any, Long]

    Cron-like schedule that recurs every specified day of month.

    Cron-like schedule that recurs every specified day of month. Won't recur on months containing less days than specified in day param.

    It triggers at zero hour of the day. Producing a count of repeats: 0, 1, 2.

    NOTE: day parameter is validated lazily. Must be in range 1...31.

  13. def dayOfWeek(day: Int)(implicit trace: Trace): WithState[(OffsetDateTime, Long), Any, Any, Long]

    Cron-like schedule that recurs every specified day of each week.

    Cron-like schedule that recurs every specified day of each week. It triggers at zero hour of the week. Producing a count of repeats: 0, 1, 2.

    NOTE: day parameter is validated lazily. Must be in range 1 (Monday)...7 (Sunday).

  14. def delayed[Env, In](schedule: Schedule[Env, In, zio.Duration])(implicit trace: Trace): WithState[State, Env, In, zio.Duration]

    Takes a schedule that produces a delay, and returns a new schedule that uses this delay to further delay intervals in the resulting schedule.

  15. def duration(duration: zio.Duration): WithState[Boolean, Any, Any, zio.Duration]

    A schedule that can recur one time, the specified amount of time into the future.

  16. val elapsed: WithState[Option[OffsetDateTime], Any, Any, zio.Duration]

    A schedule that occurs everywhere, which returns the total elapsed duration since the first step.

  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  19. def exponential(base: zio.Duration, factor: Double = 2.0)(implicit trace: Trace): WithState[Long, Any, Any, zio.Duration]

    A schedule that always recurs, but will wait a certain amount between repetitions, given by base * factor.pow(n), where n is the number of repetitions so far.

    A schedule that always recurs, but will wait a certain amount between repetitions, given by base * factor.pow(n), where n is the number of repetitions so far. Returns the current duration between recurrences.

  20. def fibonacci(one: zio.Duration)(implicit trace: Trace): WithState[(zio.Duration, zio.Duration), Any, Any, zio.Duration]

    A schedule that always recurs, increasing delays by summing the preceding two delays (similar to the fibonacci sequence).

    A schedule that always recurs, increasing delays by summing the preceding two delays (similar to the fibonacci sequence). Returns the current duration between recurrences.

  21. def fixed(interval: zio.Duration): WithState[(Option[(Long, Long)], Long), Any, Any, Long]

    A schedule that recurs on a fixed interval.

    A schedule that recurs on a fixed interval. Returns the number of repetitions of the schedule so far.

    If the action run between updates takes longer than the interval, then the action will be run immediately, but re-runs will not "pile up".

    |-----interval-----|-----interval-----|-----interval-----|
|---------action--------||action|-----|action|-----------|

  22. val forever: WithState[Long, Any, Any, Long]

    A schedule that always recurs, producing a count of repeats: 0, 1, 2.

  23. def fromDuration(duration: zio.Duration): WithState[Boolean, Any, Any, zio.Duration]

    A schedule that recurs once with the specified delay.

  24. def fromDurations(duration: zio.Duration, durations: zio.Duration*): WithState[(::[zio.Duration], Boolean), Any, Any, zio.Duration]

    A schedule that recurs once for each of the specified durations, delaying each time for the length of the specified duration.

    A schedule that recurs once for each of the specified durations, delaying each time for the length of the specified duration. Returns the length of the current duration between recurrences.

  25. def fromFunction[A, B](f: (A) => B)(implicit trace: Trace): WithState[Unit, Any, A, B]

    A schedule that always recurs, mapping input values through the specified function.

  26. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  27. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  28. def hourOfDay(hour: Int)(implicit trace: Trace): WithState[(OffsetDateTime, Long), Any, Any, Long]

    Cron-like schedule that recurs every specified hour of each day.

    Cron-like schedule that recurs every specified hour of each day. It triggers at zero minute of the hour. Producing a count of repeats: 0, 1, 2.

    NOTE: hour parameter is validated lazily. Must be in range 0...23.

  29. def identity[A]: WithState[Unit, Any, A, A]

    A schedule that always recurs, which returns inputs as outputs.

  30. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  31. def linear(base: zio.Duration)(implicit trace: Trace): WithState[Long, Any, Any, zio.Duration]

    A schedule that always recurs, but will repeat on a linear time interval, given by base * n where n is the number of repetitions so far.

    A schedule that always recurs, but will repeat on a linear time interval, given by base * n where n is the number of repetitions so far. Returns the current duration between recurrences.

  32. def maxOffsetDateTime(l: OffsetDateTime, r: OffsetDateTime): OffsetDateTime
  33. def minOffsetDateTime(l: OffsetDateTime, r: OffsetDateTime): OffsetDateTime
  34. def minuteOfHour(minute: Int)(implicit trace: Trace): WithState[(OffsetDateTime, Long), Any, Any, Long]

    Cron-like schedule that recurs every specified minute of each hour.

    Cron-like schedule that recurs every specified minute of each hour. It triggers at zero second of the minute. Producing a count of repeats: 0, 1, 2.

    NOTE: minute parameter is validated lazily. Must be in range 0...59.

  35. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  36. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  37. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  38. def once(implicit trace: Trace): WithState[Long, Any, Any, Unit]

    A schedule that recurs one time.

  39. def recurUntil[A, B](pf: PartialFunction[A, B])(implicit trace: Trace): WithState[Unit, Any, A, Option[B]]

    A schedule that recurs for until the input value becomes applicable to partial function and then map that value with given function.

  40. def recurUntil[A](f: (A) => Boolean)(implicit trace: Trace): WithState[Unit, Any, A, A]

    A schedule that recurs for until the predicate evaluates to true.

  41. def recurUntilEquals[A](a: => A)(implicit trace: Trace): WithState[Unit, Any, A, A]

    A schedule that recurs for until the predicate is equal.

  42. def recurUntilZIO[Env, A](f: (A) => URIO[Env, Boolean])(implicit trace: Trace): WithState[Unit, Env, A, A]

    A schedule that recurs for until the predicate evaluates to true.

  43. def recurWhile[A](f: (A) => Boolean)(implicit trace: Trace): WithState[Unit, Any, A, A]

    A schedule that recurs for as long as the predicate evaluates to true.

  44. def recurWhileEquals[A](a: => A)(implicit trace: Trace): WithState[Unit, Any, A, A]

    A schedule that recurs for as long as the predicate is equal.

  45. def recurWhileZIO[Env, A](f: (A) => URIO[Env, Boolean]): WithState[Unit, Env, A, A]

    A schedule that recurs for as long as the effectful predicate evaluates to true.

  46. def recurs(n: Int)(implicit trace: Trace): WithState[Long, Any, Any, Long]

    A schedule spanning all time, which can be stepped only the specified number of times before it terminates.

  47. def recurs(n: Long)(implicit trace: Trace): WithState[Long, Any, Any, Long]

    A schedule spanning all time, which can be stepped only the specified number of times before it terminates.

  48. def secondOfMinute(second0: Int)(implicit trace: Trace): WithState[(OffsetDateTime, Long), Any, Any, Long]

    Cron-like schedule that recurs every specified second of each minute.

    Cron-like schedule that recurs every specified second of each minute. It triggers at zero nanosecond of the second. Producing a count of repeats: 0, 1, 2.

    NOTE: second parameter is validated lazily. Must be in range 0...59.

  49. def spaced(duration: zio.Duration)(implicit trace: Trace): WithState[Long, Any, Any, Long]

    Returns a schedule that recurs continuously, each repetition spaced the specified duration from the last run.

  50. def stop(implicit trace: Trace): WithState[Long, Any, Any, Unit]

    A schedule that does not recur, it just stops.

  51. def succeed[A](a: => A)(implicit trace: Trace): WithState[Long, Any, Any, A]

    Returns a schedule that repeats one time, producing the specified constant value.

  52. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  53. def toString(): String
    Definition Classes
    AnyRef → Any
  54. def unfold[A](a: => A)(f: (A) => A): WithState[A, Any, Any, A]

    Unfolds a schedule that repeats one time from the specified state and iterator.

  55. def upTo(duration: zio.Duration)(implicit trace: Trace): WithState[Option[OffsetDateTime], Any, Any, zio.Duration]

    A schedule that recurs during the given duration

  56. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  57. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  58. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  59. def windowed(interval: zio.Duration): WithState[(Option[Long], Long), Any, Any, Long]

    A schedule that divides the timeline to interval-long windows, and sleeps until the nearest window boundary every time it recurs.

    A schedule that divides the timeline to interval-long windows, and sleeps until the nearest window boundary every time it recurs.

    For example, windowed(10.seconds) would produce a schedule as follows: 

         10s        10s        10s       10s
|----------|----------|----------|----------|
|action------|sleep---|act|-sleep|action----|

  60. object Decision
  61. object Interval extends (OffsetDateTime, OffsetDateTime) => Interval
  62. object Intervals extends Serializable

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped