AckedSource

Value Members

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

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

3. def ++[U >: Out, Mat2](that: AckedGraph[AckedSourceShape[U], Mat2]): Repr[U, Mat]

   

   Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

   Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

   See FlowOps.++ in akka-stream

   Definition Classes

   AckedFlowOps

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

   

   Definition Classes

   AnyRef → Any

5. def acked: akka.stream.scaladsl.Source.Repr[Out, Mat]

   

   Yields an Unwrapped Repr with only the data; after this point, message are acked.

   Yields an Unwrapped Repr with only the data; after this point, message are acked.

   Definition Classes

   AckedFlowOps

6. val akkaGraph: Source[AckTup[Out], Mat]

   

   Definition Classes

   AckedSource → AckedGraph

7. def alsoTo(that: AckedGraph[AckedSinkShape[Out], _]): Repr[Out, Mat]

   

   Definition Classes

   AckedFlowOps

8. def alsoToMat[Mat2, Mat3](that: AckedGraph[AckedSinkShape[Out], Mat2])(matF: (Mat, Mat2) ⇒ Mat3): Repr[Out, Mat3]

   

   Definition Classes

   AckedFlowOps

9. def andThen[U, Mat2](next: WrappedRepr[U, Mat2]): Repr[U, Mat2]

   

   Attributes

   protected

   Definition Classes

   AckedSource → AckedFlowOps

10. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

11. def buffer(size: Int, failOnOverflow: Boolean = false): Repr[Out, Mat]

    

    See FlowOps.buffer in akka-stream

    See FlowOps.buffer in akka-stream

    Does not accept an OverflowStrategy because only backpressure and fail are supported.

    Definition Classes

    AckedFlowOps

12. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

13. implicit def collapse1to0[U, Mat2](next: akka.stream.scaladsl.Source.Repr[AckTup[U], Mat2]): WrappedRepr[U, Mat2]

    

    Definition Classes

    AckedFlowOps

    Annotations

    @inline()

14. def collect[T](pf: PartialFunction[Out, T]): Repr[T, Mat]

    

    See FlowOps.collect in akka-stream

    See FlowOps.collect in akka-stream

    A map and a filter. Elements for which the provided PartialFunction is not defined are acked.

    Definition Classes

    AckedFlowOps

15. def completionTimeout(timeout: FiniteDuration): Repr[Out, Mat]

    

    Definition Classes

    AckedFlowOps

16. def concat[U >: Out, Mat2](that: AckedGraph[AckedSourceShape[U], Mat2]): Repr[U, Mat]

    

    Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

    Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

    See FlowOps.concat in akka-stream

    Definition Classes

    AckedFlowOps

17. def conflate[S](seed: (Out) ⇒ S)(aggregate: (S, Out) ⇒ S): Repr[S, Mat]

    

    See FlowOps.conflate in akka-stream

    See FlowOps.conflate in akka-stream

    Conflated items are grouped together into a single message, the acknowledgement of which acknowledges every message that went into the group.

    Definition Classes

    AckedFlowOps

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

    

    Definition Classes

    AnyRef

19. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

20. def filter(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

    

    Filters elements from the stream for which the predicate returns false.

    Filters elements from the stream for which the predicate returns false. Filtered items are acked.

    See FlowOps.filter in akka-stream

    Definition Classes

    AckedFlowOps

21. def filterNot(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

    

    Filters elements from the stream for which the predicate returns true.

    Filters elements from the stream for which the predicate returns true. Filtered items are acked.

    See FlowOps.filterNot in akka-stream

    Definition Classes

    AckedFlowOps

22. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

    

    Definition Classes

    AnyRef → Any

24. def groupBy[K, U >: Out](f: (Out) ⇒ K): akka.stream.scaladsl.Source.Repr[(K, AckedSource[U, Unit]), Mat]

    

    Yields a non-acked flow/source of AckedSource, keyed by the return value of the provided function.

    Yields a non-acked flow/source of AckedSource, keyed by the return value of the provided function.

    See FlowOps.groupBy in akka-stream

    Definition Classes

    AckedFlowOps

25. def grouped(n: Int): Repr[Seq[Out], Mat]

    

    See FlowOps.grouped in akka-stream

    See FlowOps.grouped in akka-stream

    Downstream acknowledgement applies to the resulting group (IE: if it yields a group of 100, then downstream you can only either ack or nack the entire group).

    Definition Classes

    AckedFlowOps

26. def groupedWithin(n: Int, d: FiniteDuration): Repr[Seq[Out], Mat]

    

    See FlowOps.groupedWithin in akka-stream

    See FlowOps.groupedWithin in akka-stream

    Downstream acknowledgement applies to the resulting group (IE: if it yields a group of 100, then downstream you can only either ack or nack the entire group).

    Definition Classes

    AckedFlowOps

27. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

28. def idleTimeout(timeout: FiniteDuration): Repr[Out, Mat]

    

    If the time between two processed elements exceed the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    If the time between two processed elements exceed the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    Definition Classes

    AckedFlowOps

29. def initialDelay(delay: FiniteDuration): Repr[Out, Mat]

    

    Delays the initial element by the specified duration.

    Delays the initial element by the specified duration.

    Definition Classes

    AckedFlowOps

30. def initialTimeout(timeout: FiniteDuration): Repr[Out, Mat]

    

    If the first element has not passed through this stage before the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    If the first element has not passed through this stage before the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    Definition Classes

    AckedFlowOps

31. def intersperse[T >: Out](start: T, inject: T, end: T): Repr[T, Mat]

    

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Definition Classes

    AckedFlowOps

32. def intersperse[T >: Out](inject: T): Repr[T, Mat]

    

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Definition Classes

    AckedFlowOps

33. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

34. def keepAlive[U >: Out](maxIdle: FiniteDuration, injectedElem: () ⇒ U): Repr[U, Mat]

    

    Injects additional elements if the upstream does not emit for a configured amount of time.

    Injects additional elements if the upstream does not emit for a configured amount of time.

    Definition Classes

    AckedFlowOps

35. def log(name: String, extract: (Out) ⇒ Any = identity)(implicit log: LoggingAdapter = null): Repr[Out, Mat]

    

    See FlowOps.log in akka-stream

    See FlowOps.log in akka-stream

    Definition Classes

    AckedFlowOps

36. def map[T](f: (Out) ⇒ T): Repr[T, Mat]

    

    See FlowOps.map in akka-stream

    See FlowOps.map in akka-stream

    Definition Classes

    AckedFlowOps

37. def mapAsync[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T, Mat]

    

    See FlowOps.mapAsync in akka-stream

    See FlowOps.mapAsync in akka-stream

    Definition Classes

    AckedFlowOps

38. def mapAsyncUnordered[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T, Mat]

    

    See FlowOps.mapAsyncUnordered in akka-stream

    See FlowOps.mapAsyncUnordered in akka-stream

    Definition Classes

    AckedFlowOps

39. def mapConcat[T](f: (Out) ⇒ Iterable[T]): Repr[T, Mat]

    

    See FlowOps.mapConcat in akka-stream

    See FlowOps.mapConcat in akka-stream

    Splits a single element into 0 or more items.

    If 0 items, then signal completion of this element. Otherwise, signal completion of this element after all resulting elements are signaled for completion.

    Definition Classes

    AckedFlowOps

40. def mapMaterializedValue[Mat2](f: (Mat) ⇒ Mat2): Repr[Out, Mat2]

    

    Transform the materialized value of this AckedSource, leaving all other properties as they were.

41. def merge[U >: Out](that: AckedGraph[AckedSourceShape[U], _]): Repr[U, Mat]

    

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking randomly when several elements ready.

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking randomly when several elements ready.

    Emits when one of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    Definition Classes

    AckedFlowOps

42. def mergeMat[U >: Out, Mat2, Mat3](that: AckedGraph[AckedSourceShape[U], Mat2])(matF: (Mat, Mat2) ⇒ Mat3): Repr[U, Mat3]

    

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking randomly when several elements ready.

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking randomly when several elements ready.

    Definition Classes

    AckedFlowOps

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

    

    Definition Classes

    AnyRef

44. final def notify(): Unit

    

    Definition Classes

    AnyRef

45. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

46. def runAck(implicit materializer: Materializer): Future[Unit]

    

47. def runAckMat[Mat2](combine: (Mat, Future[Unit]) ⇒ Mat2)(implicit materializer: Materializer): Mat2

    

    Connect this akka.stream.scaladsl.Source to a akka.stream.scaladsl.Sink, concatenating the processing steps of both.

48. def runFold[U](zero: U)(f: (U, Out) ⇒ U)(implicit materializer: Materializer): Future[U]

    

49. def runForeach(f: (Out) ⇒ Unit)(implicit materializer: Materializer): Future[Unit]

    

50. def runWith[Mat2](sink: AckedSink[Out, Mat2])(implicit materializer: Materializer): Mat2

    

51. lazy val shape: AckedSourceShape[Out]

    

    Definition Classes

    AckedSource → AckedGraph

52. def splitAfter[U >: Out](predicate: (Out) ⇒ Boolean): akka.stream.scaladsl.Source.Repr[AckedSource[U, Unit], Mat]

    

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams.

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams. It *ends* the current substream when the predicate is true. This means that for the following series of predicate values, three substreams will be produced with lengths 2, 2, and 3:

    false, true,        // elements go into first substream
    false, true,        // elements go into second substream
    false, false, true  // elements go into third substream

    If the split predicate p throws an exception and the supervision decision is akka.stream.Supervision.Stop the stream and substreams will be completed with failure.

    If the split predicate p throws an exception and the supervision decision is akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the element is dropped and the stream and substreams continue.

    Emits when an element passes through. When the provided predicate is true it emitts the element and opens a new substream for subsequent element

    Backpressures when there is an element pending for the next substream, but the previous is not fully consumed yet, or the substream backpressures

    Completes when upstream completes

    Cancels when downstream cancels and substreams cancel

    See also FlowOps.splitWhen.

    Definition Classes

    AckedFlowOps

53. def splitWhen[U >: Out](predicate: (Out) ⇒ Boolean): akka.stream.scaladsl.Source.Repr[AckedSource[U, Unit], Mat]

    

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams, always beginning a new one with the current element if the given predicate returns true for it.

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams, always beginning a new one with the current element if the given predicate returns true for it. This means that for the following series of predicate values, three substreams will be produced with lengths 1, 2, and 3:

    false,             // element goes into first substream
    true, false,       // elements go into second substream
    true, false, false // elements go into third substream

    In case the *first* element of the stream matches the predicate, the first substream emitted by splitWhen will start from that element. For example:

    true, false, false // first substream starts from the split-by element
    true, false        // subsequent substreams operate the same way

    If the split predicate p throws an exception and the supervision decision is akka.stream.Supervision.Stop the stream and substreams will be completed with failure.

    If the split predicate p throws an exception and the supervision decision is akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the element is dropped and the stream and substreams continue.

    Exceptions thrown in predicate will be propagated via the acknowledgement channel

    Emits when an element for which the provided predicate is true, opening and emitting a new substream for subsequent element

    Backpressures when there is an element pending for the next substream, but the previous is not fully consumed yet, or the substream backpressures

    Completes when upstream completes

    Cancels when downstream cancels and substreams cancel

    Definition Classes

    AckedFlowOps

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

    

    Definition Classes

    AnyRef

55. def take(n: Long): Repr[Out, Mat]

    

    See FlowOps.take in akka-stream

    See FlowOps.take in akka-stream

    Definition Classes

    AckedFlowOps

56. def takeWhile(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

    

    See FlowOps.takeWhile in akka-stream

    See FlowOps.takeWhile in akka-stream

    Definition Classes

    AckedFlowOps

57. def takeWithin(d: FiniteDuration): Repr[Out, Mat]

    

    See FlowOps.takeWithin in akka-stream

    See FlowOps.takeWithin in akka-stream

    Definition Classes

    AckedFlowOps

58. def to[Mat2](sink: AckedSink[Out, Mat2]): RunnableGraph[Mat]

    

59. def toMat[Mat2, Mat3](sink: AckedSink[Out, Mat2])(combine: (Mat, Mat2) ⇒ Mat3): RunnableGraph[Mat3]

    

60. def toString(): String

    

    Definition Classes

    AnyRef → Any

61. def unsafe: WrappedRepr[Out, Mat]

    

    Yields an unacked Repr with the promise and the data.

    Yields an unacked Repr with the promise and the data. Note, this is inherently unsafe, as the method says. There is no timeout for the acknowledgement promises. Failing to complete the promises will cause a consumer with a non-infinite QoS to eventually stall.

    Definition Classes

    AckedFlowOps

62. def via[T, Mat2](flow: AckedGraph[AckedFlowShape[Out, T], Mat2]): AckedSource[T, Mat]

    

    See Source.via in akka-stream

63. def viaMat[T, Mat2, Mat3](flow: AckedGraph[AckedFlowShape[Out, T], Mat2])(combine: (Mat, Mat2) ⇒ Mat3): AckedSource[T, Mat3]

    

    See Source.viaMat in akka-stream

64. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

67. def wrapShape(akkaShape: akka.stream.scaladsl.Source.Shape): Self

    

    Definition Classes

    AckedGraph

68. val wrappedRepr: Source[AckTup[Out], Mat]

    

    Definition Classes

    AckedSource → AckedFlowOps

69. def zip[U](that: AckedGraph[AckedSourceShape[U], _]): Repr[(Out, U), Mat]

    

    Combine the elements of current flow and the given Source into a stream of tuples.

    Combine the elements of current flow and the given Source into a stream of tuples.

    Definition Classes

    AckedFlowOps

70. def zipMat[U, Mat2, Mat3](that: AckedGraph[AckedSourceShape[U], Mat2])(matF: (Mat, Mat2) ⇒ Mat3): Repr[(Out, U), Mat3]

    

    Combine the elements of current flow and the given Source into a stream of tuples.

    Combine the elements of current flow and the given Source into a stream of tuples.

    Definition Classes

    AckedFlowOps

71. def zipWith[Out2, Out3](that: AckedGraph[AckedSourceShape[Out2], _])(combine: (Out, Out2) ⇒ Out3): Repr[Out3, Mat]

    

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function.

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function.

    Definition Classes

    AckedFlowOps

72. def zipWithMat[Out2, Out3, Mat2, Mat3](that: AckedGraph[AckedSourceShape[Out2], Mat2])(combine: (Out, Out2) ⇒ Out3)(matF: (Mat, Mat2) ⇒ Mat3): Repr[Out3, Mat3]

    

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function.

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function.

    Definition Classes

    AckedFlowOps