Package akka.remote

Class EndpointWriter

    • Method Detail

      • sender

        public static final ActorRef sender()
      • aroundReceive

        protected static void aroundReceive​(scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> receive,
                                            java.lang.Object msg)
      • aroundPreStart

        protected static void aroundPreStart()
      • aroundPostStop

        protected static void aroundPostStop()
      • aroundPreRestart

        protected static void aroundPreRestart​(java.lang.Throwable reason,
                                               scala.Option<java.lang.Object> message)
      • aroundPostRestart

        protected static void aroundPostRestart​(java.lang.Throwable reason)
      • preRestart

        public static void preRestart​(java.lang.Throwable reason,
                                      scala.Option<java.lang.Object> message)
                               throws java.lang.Exception
        Throws:
        java.lang.Exception
      • localAddress

        public static Address localAddress()
      • remoteAddress

        public static Address remoteAddress()
      • transport

        public static Transport transport()
      • publishError

        public static void publishError​(java.lang.Throwable reason,
                                        Logging.LogLevel logLevel)
      • publishDisassociated

        public static void publishDisassociated()
      • akka$actor$ActorLogging$$_log

        public static LoggingAdapter akka$actor$ActorLogging$$_log()
      • akka$actor$ActorLogging$$_log_$eq

        public static void akka$actor$ActorLogging$$_log_$eq​(LoggingAdapter x$1)
      • self

        public static final ActorRef self()
      • akka$actor$Actor$_setter_$context_$eq

        protected static void akka$actor$Actor$_setter_$context_$eq​(ActorContext x$1)
      • akka$actor$Actor$_setter_$self_$eq

        protected static final void akka$actor$Actor$_setter_$self_$eq​(ActorRef x$1)
      • reliableDeliverySupervisor

        public scala.Option<ActorRef> reliableDeliverySupervisor()
      • reader

        public scala.Option<ActorRef> reader()
      • reader_$eq

        public void reader_$eq​(scala.Option<ActorRef> x$1)
      • readerId

        public scala.collection.Iterator<java.lang.Object> readerId()
      • newAckDeadline

        public scala.concurrent.duration.Deadline newAckDeadline()
      • ackDeadline

        public scala.concurrent.duration.Deadline ackDeadline()
      • ackDeadline_$eq

        public void ackDeadline_$eq​(scala.concurrent.duration.Deadline x$1)
      • lastAck

        public scala.Option<Ack> lastAck()
      • lastAck_$eq

        public void lastAck_$eq​(scala.Option<Ack> x$1)
      • supervisorStrategy

        public OneForOneStrategy supervisorStrategy()
        Description copied from interface: Actor
        User overridable definition the strategy to use for supervising child actors.
        Returns:
        (undocumented)
      • buffer

        public java.util.LinkedList<java.lang.Object> buffer()
      • largeBufferLogTimestamp

        public long largeBufferLogTimestamp()
      • largeBufferLogTimestamp_$eq

        public void largeBufferLogTimestamp_$eq​(long x$1)
      • preStart

        public void preStart()
        Description copied from interface: Actor
        User overridable callback.

        Is called when an Actor is started. Actors are automatically started asynchronously when created. Empty default implementation.
      • postRestart

        public void postRestart​(java.lang.Throwable reason)
        Description copied from interface: Actor
        User overridable callback: By default it calls preStart().
        Parameters:
        reason - the Throwable that caused the restart to happen

        Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.
      • postStop

        public void postStop()
        Description copied from interface: Actor
        User overridable callback.

        Is called asynchronously after 'actor.stop()' is invoked. Empty default implementation.
      • receive

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> receive()
        Description copied from interface: Actor
        Scala API: This defines the initial actor behavior, it must return a partial function with the actor logic.
        Returns:
        (undocumented)
      • initializing

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> initializing()
      • enqueueInBuffer

        public void enqueueInBuffer​(java.lang.Object msg)
      • buffering

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> buffering()
      • becomeWritingOrSendBufferedMessages

        public void becomeWritingOrSendBufferedMessages()
      • writeCount

        public int writeCount()
      • writeCount_$eq

        public void writeCount_$eq​(int x$1)
      • maxWriteCount

        public int maxWriteCount()
      • maxWriteCount_$eq

        public void maxWriteCount_$eq​(int x$1)
      • adaptiveBackoffNanos

        public long adaptiveBackoffNanos()
      • adaptiveBackoffNanos_$eq

        public void adaptiveBackoffNanos_$eq​(long x$1)
      • fullBackoff

        public boolean fullBackoff()
      • fullBackoff_$eq

        public void fullBackoff_$eq​(boolean x$1)
      • fullBackoffCount

        public int fullBackoffCount()
      • fullBackoffCount_$eq

        public void fullBackoffCount_$eq​(int x$1)
      • smallBackoffCount

        public int smallBackoffCount()
      • smallBackoffCount_$eq

        public void smallBackoffCount_$eq​(int x$1)
      • noBackoffCount

        public int noBackoffCount()
      • noBackoffCount_$eq

        public void noBackoffCount_$eq​(int x$1)
      • adjustAdaptiveBackup

        public void adjustAdaptiveBackup()
      • sendBufferedMessages

        public void sendBufferedMessages()
      • scheduleBackoffTimer

        public void scheduleBackoffTimer()
      • writing

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> writing()
      • handoff

        public scala.PartialFunction<java.lang.Object,​scala.runtime.BoxedUnit> handoff()
      • unhandled

        public void unhandled​(java.lang.Object message)
        Description copied from interface: Actor
        User overridable callback.

        Is called when a message isn't handled by the current behavior of the actor by default it fails with either a DeathPactException (in case of an unhandled Terminated message) or publishes an UnhandledMessage to the actor's system's EventStream
        Parameters:
        message - (undocumented)
      • flushAndStop

        public void flushAndStop()