Enumerator

Abstract Value Members

abstract def apply[A](i: Iteratee[E, A]): Future[Iteratee[E, A]]

Attaches this Enumerator to an play.api.libs.iteratee.Iteratee, driving the Iteratee to (asynchronously) consume the input.
Attaches this Enumerator to an play.api.libs.iteratee.Iteratee, driving the Iteratee to (asynchronously) consume the input. The Iteratee may enter its play.api.libs.iteratee.Done or play.api.libs.iteratee.Error state, or it may be left in a play.api.libs.iteratee.Cont state (allowing it to consume more input after that sent by the enumerator).
If the Iteratee reaches a play.api.libs.iteratee.Done state, it will contain a computed result and the remaining (unconsumed) input.

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def &>[To](enumeratee: Enumeratee[E, To]): Enumerator[To]

Compose this Enumerator with an Enumeratee.
Compose this Enumerator with an Enumeratee. Alias for through
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >-[B >: E](other: Enumerator[B]): Enumerator[B]

Alias for interleave
def >>>(e: Enumerator[E]): Enumerator[E]

Alias for andThen
def andThen(e: Enumerator[E]): Enumerator[E]

Sequentially combine this Enumerator with another Enumerator.
Sequentially combine this Enumerator with another Enumerator. The resulting enumerator will produce both input streams, this one first, then the other. Note: the current implementation will break if the first enumerator produces an Input.EOF.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[U](f: (E) ⇒ Enumerator[U])(implicit ec: ExecutionContext): Enumerator[U]

flatmaps the given function f onto parent Enumerator
flatmaps the given function f onto parent Enumerator
f
function to map
ec
The context to execute the supplied function with. The context is prepared on the calling thread before being used.
returns
enumerator
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def interleave[B >: E](other: Enumerator[B]): Enumerator[B]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def map[U](f: (E) ⇒ U)(implicit ec: ExecutionContext): Enumerator[U]

maps the given function f onto parent Enumerator
maps the given function f onto parent Enumerator
f
function to map
ec
The context to execute the supplied function with. The context is prepared on the calling thread before being used.
returns
enumerator
def mapInput[U](f: (Input[E]) ⇒ Input[U])(implicit ec: ExecutionContext): Enumerator[U]

Creates an Enumerator, based on this one, with each input transformed by the given function.
Creates an Enumerator, based on this one, with each input transformed by the given function.
f
Used to transform the input.
ec
The context to execute the supplied function with. The context is prepared on the calling thread before being used.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onDoneEnumerating(callback: ⇒ Unit)(implicit ec: ExecutionContext): Enumerator[E]

Creates an Enumerator which calls the given callback when a passed in iteratee has either entered the done state, or if an error is returned.
Creates an Enumerator which calls the given callback when a passed in iteratee has either entered the done state, or if an error is returned.
This is equivalent to a finally call, and can be used to clean up any resources used by this enumerator. Note that if the callback throws an exception, then the future returned by the enumerator will be completed with that exception.
callback
The callback to call
ec
The context to execute the supplied function with. The context is prepared on the calling thread before being used.
def run[A](i: Iteratee[E, A]): Future[A]

Alias for |>>>; drives the iteratee to consume the enumerator's input, adding an Input.EOF at the end of the input.
Alias for |>>>; drives the iteratee to consume the enumerator's input, adding an Input.EOF at the end of the input. Returns either a result or an exception.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def through[To](enumeratee: Enumeratee[E, To]): Enumerator[To]

Compose this Enumerator with an Enumeratee
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def |>>[A](i: Iteratee[E, A]): Future[Iteratee[E, A]]

Alias for apply, produces input driving the given play.api.libs.iteratee.Iteratee to consume it.
def |>>>[A](i: Iteratee[E, A]): Future[A]

Attaches this Enumerator to an play.api.libs.iteratee.Iteratee, driving the Iteratee to (asynchronously) consume the enumerator's input.
Attaches this Enumerator to an play.api.libs.iteratee.Iteratee, driving the Iteratee to (asynchronously) consume the enumerator's input. If the Iteratee does not reach a play.api.libs.iteratee.Done or play.api.libs.iteratee.Error state when the Enumerator finishes, this method forces one of those states by feeding Input.EOF to the Iteratee.
If the iteratee is left in a play.api.libs.iteratee.Done state then the promise is completed with the iteratee's result. If the iteratee is left in an play.api.libs.iteratee.Error state, then the promise is completed with a RuntimeException containing the iteratee's error message.
Unlike apply or |>>, this method does not allow you to access the unconsumed input.
def |>>|[A](i: Iteratee[E, A]): Future[Step[E, A]]

A variation on apply or |>> which returns the state of the iteratee rather than the iteratee itself.
A variation on apply or |>> which returns the state of the iteratee rather than the iteratee itself. This can make your code a little shorter.

Related Docs: object Enumerator | package iteratee

trait Enumerator[E] extends AnyRef

Abstract Value Members

abstract def apply[A](i: Iteratee[E, A]): Future[Iteratee[E, A]]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def &>[To](enumeratee: Enumeratee[E, To]): Enumerator[To]

final def ==(arg0: Any): Boolean

def >-[B >: E](other: Enumerator[B]): Enumerator[B]

def >>>(e: Enumerator[E]): Enumerator[E]

def andThen(e: Enumerator[E]): Enumerator[E]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[U](f: (E) ⇒ Enumerator[U])(implicit ec: ExecutionContext): Enumerator[U]

final def getClass(): Class[_]

def hashCode(): Int

def interleave[B >: E](other: Enumerator[B]): Enumerator[B]

final def isInstanceOf[T0]: Boolean

def map[U](f: (E) ⇒ U)(implicit ec: ExecutionContext): Enumerator[U]

def mapInput[U](f: (Input[E]) ⇒ Input[U])(implicit ec: ExecutionContext): Enumerator[U]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onDoneEnumerating(callback: ⇒ Unit)(implicit ec: ExecutionContext): Enumerator[E]

def run[A](i: Iteratee[E, A]): Future[A]

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

def through[To](enumeratee: Enumeratee[E, To]): Enumerator[To]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |>>[A](i: Iteratee[E, A]): Future[Iteratee[E, A]]

def |>>>[A](i: Iteratee[E, A]): Future[A]

def |>>|[A](i: Iteratee[E, A]): Future[Step[E, A]]

Inherited from AnyRef

Inherited from Any

Ungrouped