play.api.libs.iteratee

Enumeratee

object Enumeratee

Source
Enumeratee.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Enumeratee
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. trait CheckDone[From, To] extends Enumeratee[From, To]

    An Enumeratee that checks to ensure that the passed in Iteratee is not done before doing any work.

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. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  7. def breakE[E](p: (E) ⇒ Boolean): Enumeratee[E, E]

  8. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  9. def collect[From]: AnyRef { def apply[To](transformer: PartialFunction[From,To]): play.api.libs.iteratee.Enumeratee[From,To] }

  10. def drop[E](count: Int): Enumeratee[E, E]

  11. def dropWhile[E](p: (E) ⇒ Boolean): Enumeratee[E, E]

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

    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  14. def filter[E](predicate: (E) ⇒ Boolean): Enumeratee[E, E]

    Create an Enumeratee that filters the inputs using the given predicate

  15. def filterNot[E](predicate: (E) ⇒ Boolean): Enumeratee[E, E]

    Create an Enumeratee that filters the inputs using the negation of the given predicate

  16. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  17. def flatten[From, To](futureOfEnumeratee: Future[Enumeratee[From, To]]): Enumeratee[From, To]

    flatten a scala.concurrent.Future of play.api.libs.iteratee.Enumeratee] into an Enumeratee

    flatten a scala.concurrent.Future of play.api.libs.iteratee.Enumeratee] into an Enumeratee

    futureOfEnumeratee

    a future of enumeratee

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

    Definition Classes
    AnyRef → Any
  19. def grouped[From]: AnyRef { def apply[To](folder: play.api.libs.iteratee.Iteratee[From,To]): play.api.libs.iteratee.Enumeratee[From,To] }

    Create an Enumeratee that groups input using the given Iteratee.

    Create an Enumeratee that groups input using the given Iteratee.

    This will apply that Iteratee over and over, passing the result each time as the input for the target Iteratee, until EOF is reached. For example, let's say you had an Iteratee that took a stream of characters and parsed a single line:

    def takeLine = for {
      line <- Enumeratee.takeWhile[Char](_ != '\n') &>> Iteratee.getChunks
      _    <- Enumeratee.take(1) &>> Iteratee.ignore[Char]
    } yield line.mkString

    This could be used to build an Enumeratee that converts a stream of characters into a stream of lines:

    def asLines = Enumeratee.grouped(takeLine)
  20. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  21. def heading[E](es: Enumerator[E]): Enumeratee[E, E]

  22. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  23. def map[E]: AnyRef { def apply[NE](f: E => NE): play.api.libs.iteratee.Enumeratee[E,NE] }

    Create an Enumeratee which transforms its input using a given function

  24. def mapConcat[From]: AnyRef { def apply[To](f: From => Seq[To]): play.api.libs.iteratee.Enumeratee.CheckDone[From,To]{def step[A](k: play.api.libs.iteratee.Input[To] => play.api.libs.iteratee.Iteratee[To,A]): play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Iteratee[From,play.api.libs.iteratee.Iteratee[To,A]]} }

    Create an Enumeratee that transforms its input elements into a sequence of input elements for the target Iteratee.

  25. def mapConcatInput[From]: AnyRef { def apply[To](f: From => Seq[play.api.libs.iteratee.Input[To]]): play.api.libs.iteratee.Enumeratee.CheckDone[From,To]{def step[A](k: play.api.libs.iteratee.Input[To] => play.api.libs.iteratee.Iteratee[To,A]): play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Iteratee[From,play.api.libs.iteratee.Iteratee[To,A]]} }

    Create an enumeratee that transforms its input into a sequence of inputs for the target iteratee.

  26. def mapFlatten[From]: AnyRef { def apply[To](f: From => play.api.libs.iteratee.Enumerator[To]): play.api.libs.iteratee.Enumeratee.CheckDone[From,To]{def step[A](k: play.api.libs.iteratee.Input[To] => play.api.libs.iteratee.Iteratee[To,A]): play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Iteratee[From,play.api.libs.iteratee.Iteratee[To,A]]} }

    Create an Enumeratee that transforms its input elements into an Enumerator that is fed into the target Iteratee.

  27. def mapInput[From]: AnyRef { def apply[To](f: play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Input[To]): play.api.libs.iteratee.Enumeratee.CheckDone[From,To]{def step[A](k: play.api.libs.iteratee.Input[To] => play.api.libs.iteratee.Iteratee[To,A]): play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Iteratee[From,play.api.libs.iteratee.Iteratee[To,A]]} }

    Create an Enumeratee that transforms its input using the given function.

    Create an Enumeratee that transforms its input using the given function.

    This is like the map function, except that it allows the Enumeratee to, for example, send EOF to the inner iteratee before EOF is encountered.

  28. def mapInputFlatten[From]: AnyRef { def apply[To](f: play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Enumerator[To]): play.api.libs.iteratee.Enumeratee.CheckDone[From,To]{def step[A](k: play.api.libs.iteratee.Input[To] => play.api.libs.iteratee.Iteratee[To,A]): play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Iteratee[From,play.api.libs.iteratee.Iteratee[To,A]]} }

    Create an Enumeratee that transforms its input into an Enumerator that is fed into the target Iteratee.

  29. def mapInputM[From]: AnyRef { def apply[To](f: play.api.libs.iteratee.Input[From] => scala.concurrent.Future[play.api.libs.iteratee.Input[To]]): play.api.libs.iteratee.Enumeratee.CheckDone[From,To]{def step[A](k: play.api.libs.iteratee.Input[To] => play.api.libs.iteratee.Iteratee[To,A]): play.api.libs.iteratee.Input[From] => play.api.libs.iteratee.Iteratee[From,play.api.libs.iteratee.Iteratee[To,A]]} }

    Like mapInput, but allows the map function to asynchronously return the mapped input.

  30. def mapM[E]: AnyRef { def apply[NE](f: E => scala.concurrent.Future[NE]): play.api.libs.iteratee.Enumeratee[E,NE] }

    Like map, but allows the map function to asynchronously return the mapped element.

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

    Definition Classes
    AnyRef
  32. final def notify(): Unit

    Definition Classes
    AnyRef
  33. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  34. def onEOF[E](action: () ⇒ Unit): Enumeratee[E, E]

  35. def onIterateeDone[E](action: () ⇒ Unit): Enumeratee[E, E]

  36. def passAlong[M]: CheckDone[M, M] { def step[A](k: play.api.libs.iteratee.Input[M] => play.api.libs.iteratee.Iteratee[M,A]): play.api.libs.iteratee.Input[M] => play.api.libs.iteratee.Iteratee[M,play.api.libs.iteratee.Iteratee[M,A]] }

  37. def scanLeft[From]: AnyRef { def apply[To](seed: To)(f: (To, From) => To): play.api.libs.iteratee.Enumeratee[From,To] }

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

    Definition Classes
    AnyRef
  39. def take[E](count: Int): Enumeratee[E, E]

    Create an Enumeratee that will take count input elements to pass to the target Iteratee, and then be done

    Create an Enumeratee that will take count input elements to pass to the target Iteratee, and then be done

    count

    The number of elements to take

  40. def takeWhile[E](p: (E) ⇒ Boolean): Enumeratee[E, E]

  41. def toString(): String

    Definition Classes
    AnyRef → Any
  42. def trailing[M](es: Enumerator[M]): CheckDone[M, M] { def step[A](k: play.api.libs.iteratee.Input[M] => play.api.libs.iteratee.Iteratee[M,A]): play.api.libs.iteratee.Input[M] => play.api.libs.iteratee.Iteratee[M,play.api.libs.iteratee.Iteratee[M,A]] }

  43. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  44. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  45. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  46. def zip[E, A, B](inner1: Iteratee[E, A], inner2: Iteratee[E, B]): Iteratee[E, (A, B)]

    Create an Enumeratee that zips two Iteratees together.

    Create an Enumeratee that zips two Iteratees together.

    Each input gets passed to each Iteratee, and the result is a tuple of both of their results.

    If either Iteratee encounters an error, the result will be an error.

    The Enumeratee will continue consuming input until both inner Iteratees are done. If one inner Iteratee finishes before the other, the result of that Iteratee is held, and the one continues by itself, until it too is finished.

  47. def zipWith[E, A, B, C](inner1: Iteratee[E, A], inner2: Iteratee[E, B])(zipper: (A, B) ⇒ C): Iteratee[E, C]

    Create an Enumeratee that zips two Iteratees together, using the passed in zipper function to combine the results of the two.

Inherited from AnyRef

Inherited from Any

Ungrouped