Class ActorFlow$


  • public class ActorFlow$
    extends java.lang.Object
    Collection of Flows aimed at integrating with typed Actors.
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static ActorFlow$ MODULE$
      Static reference to the singleton instance of this Scala object.
    • Constructor Summary

      Constructors 
      Constructor Description
      ActorFlow$()  
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      <I,​Q,​A>
      Flow<I,​A,​NotUsed>
      ask​(int parallelism, ActorRef<Q> ref, scala.Function2<I,​ActorRef<A>,​Q> makeMessage, Timeout timeout)
      Use the ask pattern to send a request-reply message to the target ref actor.
      <I,​Q,​A>
      Flow<I,​A,​NotUsed>
      ask​(ActorRef<Q> ref, scala.Function2<I,​ActorRef<A>,​Q> makeMessage, Timeout timeout)
      Use the ask pattern to send a request-reply message to the target ref actor.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • MODULE$

        public static final ActorFlow$ MODULE$
        Static reference to the singleton instance of this Scala object.
    • Constructor Detail

      • ActorFlow$

        public ActorFlow$()
    • Method Detail

      • ask

        public <I,​Q,​A> Flow<I,​A,​NotUsed> ask​(ActorRef<Q> ref,
                                                                     scala.Function2<I,​ActorRef<A>,​Q> makeMessage,
                                                                     Timeout timeout)
        Use the ask pattern to send a request-reply message to the target ref actor. If any of the asks times out it will fail the stream with a TimeoutException.

        Do not forget to include the expected response type in the method call, like so:

        
         flow.via(ActorFlow.ask[String, Asking, Reply](ref)((el, replyTo) => Asking(el, replyTo)))
        
         // or even:
         flow.via(ActorFlow.ask[String, Asking, Reply](ref)(Asking(_, _)))
         

        otherwise Nothing will be assumed, which is most likely not what you want.

        Defaults to parallelism of 2 messages in flight, since while one ask message may be being worked on, the second one still be in the mailbox, so defaulting to sending the second one a bit earlier than when first ask has replied maintains a slightly healthier throughput.

        The operator fails with an WatchedActorTerminatedException if the target actor is terminated, or with an TimeoutException in case the ask exceeds the timeout passed in.

        Adheres to the ActorAttributes.SupervisionStrategy attribute.

        '''Emits when''' the futures (in submission order) created by the ask pattern internally are completed

        '''Backpressures when''' the number of futures reaches the configured parallelism and the downstream backpressures

        '''Completes when''' upstream completes and all futures have been completed and all elements have been emitted

        '''Fails when''' the passed in actor terminates, or a timeout is exceeded in any of the asks performed

        '''Cancels when''' downstream cancels

        Parameters:
        ref - (undocumented)
        makeMessage - (undocumented)
        timeout - (undocumented)
        Returns:
        (undocumented)
      • ask

        public <I,​Q,​A> Flow<I,​A,​NotUsed> ask​(int parallelism,
                                                                     ActorRef<Q> ref,
                                                                     scala.Function2<I,​ActorRef<A>,​Q> makeMessage,
                                                                     Timeout timeout)
        Use the ask pattern to send a request-reply message to the target ref actor. If any of the asks times out it will fail the stream with a TimeoutException.

        Do not forget to include the expected response type in the method call, like so:

        
         flow.via(ActorFlow.ask[String, Asking, Reply](parallelism = 4)(ref, (el, replyTo) => Asking(el, replyTo)))
        
         // or even:
         flow.via(ActorFlow.ask[String, Asking, Reply](parallelism = 4)(ref, Asking(_, _)))
         

        otherwise Nothing will be assumed, which is most likely not what you want.

        The operator fails with an WatchedActorTerminatedException if the target actor is terminated, or with an TimeoutException in case the ask exceeds the timeout passed in.

        Adheres to the ActorAttributes.SupervisionStrategy attribute.

        '''Emits when''' the futures (in submission order) created by the ask pattern internally are completed

        '''Backpressures when''' the number of futures reaches the configured parallelism and the downstream backpressures

        '''Completes when''' upstream completes and all futures have been completed and all elements have been emitted

        '''Fails when''' the passed in actor terminates, or a timeout is exceeded in any of the asks performed

        '''Cancels when''' downstream cancels

        Parameters:
        parallelism - (undocumented)
        ref - (undocumented)
        makeMessage - (undocumented)
        timeout - (undocumented)
        Returns:
        (undocumented)