akka.stream.javadsl

Sink

object Sink

Java API

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

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. def actorRef[In](ref: ActorRef, onCompleteMessage: Any): Sink[In, Unit]

    Sends the elements of the stream to the given ActorRef.

    Sends the elements of the stream to the given ActorRef. If the target actor terminates the stream will be cancelled. When the stream is completed successfully the given onCompleteMessage will be sent to the destination actor. When the stream is completed with failure a akka.actor.Status.Failure message will be sent to the destination actor.

    It will request at most maxInputBufferSize number of elements from upstream, but there is no back-pressure signal from the destination actor, i.e. if the actor is not consuming the messages fast enough the mailbox of the actor will grow. For potentially slow consumer actors it is recommended to use a bounded mailbox with zero mailbox-push-timeout-time or use a rate limiting stage in front of this Sink.

  7. def actorSubscriber[T](props: Props): Sink[T, ActorRef]

    Creates a Sink that is materialized to an akka.actor.ActorRef which points to an Actor created according to the passed in akka.actor.Props.

    Creates a Sink that is materialized to an akka.actor.ActorRef which points to an Actor created according to the passed in akka.actor.Props. Actor created by the props should be akka.stream.actor.ActorSubscriber.

  8. def adapt[O, M](sink: scaladsl.Sink[O, M]): Sink[O, M]

    Adapt scaladsl.Sink for use within Java DSL

  9. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  10. def cancelled[T](): Sink[T, Unit]

    A Sink that immediately cancels its upstream after materialization.

  11. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  12. def create[In](subs: Subscriber[In]): Sink[In, Unit]

    Helper to create Sink from Subscriber.

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

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

    Definition Classes
    AnyRef → Any
  15. val factory: SinkCreate

  16. def fanoutPublisher[T](initialBufferSize: Int, maximumBufferSize: Int): Sink[T, Publisher[T]]

    A Sink that materializes into a org.reactivestreams.Publisher that can handle more than one org.reactivestreams.Subscriber.

  17. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  18. def fold[U, In](zero: U, f: Function2[U, In, U]): Sink[In, Future[U]]

    A Sink that will invoke the given function for every received element, giving it its previous output (or the given zero value) and the element as input.

    A Sink that will invoke the given function for every received element, giving it its previous output (or the given zero value) and the element as input. The returned scala.concurrent.Future will be completed with value of the final function evaluation when the input stream ends, or completed with Failure if there is a failure is signaled in the stream.

  19. def foreach[T](f: Procedure[T]): Sink[T, Future[Unit]]

    A Sink that will invoke the given procedure for each received element.

    A Sink that will invoke the given procedure for each received element. The sink is materialized into a scala.concurrent.Future will be completed with Success when reaching the normal end of the stream, or completed with Failure if there is a failure is signaled in the stream..

  20. def foreachParallel[T](parallel: Int)(f: Procedure[T])(ec: ExecutionContext): Sink[T, Future[Unit]]

    A Sink that will invoke the given procedure for each received element in parallel.

    A Sink that will invoke the given procedure for each received element in parallel. The sink is materialized into a scala.concurrent.Future.

    If f throws an exception and the supervision decision is akka.stream.Supervision.Stop the Future will be completed with failure.

    If f throws an exception and the supervision decision is akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the element is dropped and the stream continues.

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

    Definition Classes
    AnyRef → Any
  22. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  23. def head[In](): Sink[In, Future[In]]

    A Sink that materializes into a Future of the first value received.

  24. def ignore[T](): Sink[T, Future[Unit]]

    A Sink that will consume the stream and discard the elements.

  25. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  26. final def ne(arg0: AnyRef): Boolean

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

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

    Definition Classes
    AnyRef
  29. def onComplete[In](callback: Procedure[Try[Unit]]): Sink[In, Unit]

    A Sink that when the flow is completed, either through a failure or normal completion, apply the provided function with scala.util.Success or scala.util.Failure.

  30. def publisher[In](): Sink[In, Publisher[In]]

    A Sink that materializes into a org.reactivestreams.Publisher.

    A Sink that materializes into a org.reactivestreams.Publisher. that can handle one org.reactivestreams.Subscriber.

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

    Definition Classes
    AnyRef
  32. def toString(): String

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

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  36. def wrap[T, M](g: Graph[SinkShape[T], M]): Sink[T, M]

    A graph with the shape of a sink logically is a sink, this method makes it so also in type.

Inherited from AnyRef

Inherited from Any

Ungrouped