Actor

Instance Constructors

new Actor(name: String, state: S, queue: ActorQueue[(T, Int)], stashCapacity: Int, weigher: (T) ⇒ Int, cached: Boolean, execution: (T, Actor[T, S]) ⇒ Unit, scheduler: CacheNoIO[Unit, Scheduler], interval: Option[Interval], preTerminate: Option[(Actor[T, S]) ⇒ Unit], postTerminate: Option[(Actor[T, S]) ⇒ Unit], recovery: Option[(T, IO[Throwable, Actor.Error], Actor[T, S]) ⇒ Unit])(implicit executionContext: ExecutionContext)

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def ask[R, X[_]](message: (ActorRef[R, Unit]) ⇒ T, delay: FiniteDuration)(implicit bag: Async[X]): Task[R, X]

Definition Classes
Actor → ActorRef
def ask[R, X[_]](message: (ActorRef[R, Unit]) ⇒ T)(implicit bag: Async[X]): X[R]

Definition Classes
Actor → ActorRef
def clear(): Unit

Definition Classes
Actor → ActorRef
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
implicit val executionContext: ExecutionContext

Definition Classes
Actor → ActorRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hasMessages: Boolean

Definition Classes
ActorRef
def hasRecovery: Boolean

Definition Classes
Actor → ActorRef
def hashCode(): Int

Definition Classes
AnyRef → Any
def isEmpty: Boolean

Definition Classes
Actor → ActorRef
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isNotEmpty: Boolean

Definition Classes
ActorRef
Annotations
@inline()
def isTerminated: Boolean

Definition Classes
Actor → ActorRef
lazy val logger: Logger

Attributes
protected
Definition Classes
LazyLogging
def messageCount: Int

Definition Classes
Actor → ActorRef
val name: String

Definition Classes
Actor → ActorRef
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onPostTerminate(f: (Actor[T, S]) ⇒ Unit): ActorRef[T, S]

Definition Classes
Actor → ActorRef
def onPreTerminate(f: (Actor[T, S]) ⇒ Unit): ActorRef[T, S]

Definition Classes
Actor → ActorRef
def receiveAllForce[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

Forces the Actor to process all queued messages.
Forces the Actor to process all queued messages.

Definition Classes
Actor → ActorRef
def recover[M <: T, E](f: (M, IO[E, Actor.Error], Actor[T, S]) ⇒ Unit)(implicit arg0: ExceptionHandler[E]): ActorRef[T, S]

Definition Classes
Actor → ActorRef
def recoverException[M <: T](f: (M, IO[Throwable, Actor.Error], Actor[T, S]) ⇒ Unit): ActorRef[T, S]

Definition Classes
ActorRef
def send(message: T): Unit

Definition Classes
Actor → ActorRef
def send(message: T, delay: FiniteDuration): TimerTask

Sends a message to this actor with delay
Sends a message to this actor with delay

Definition Classes
Actor → ActorRef
val state: S
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def terminate[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

We cannot invoke terminate from within the Actor itself via block because busy is already set to true within receive.
We cannot invoke terminate from within the Actor itself via block because busy is already set to true within receive. AtomicThreadLocalBoolean can be used instead to allow calling terminating from within the Actor itself but this is currently not required anywhere.
Currently there is no use to terminate from within the Actor itself.

Definition Classes
Actor → ActorRef
def terminateAfter(timeout: FiniteDuration): ActorRef[T, S]

Definition Classes
Actor → ActorRef
def terminateAndClear[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

Definition Classes
Actor → ActorRef
def terminateAndRecover[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

Terminates the Actor and applies recover function to all queued messages.
Terminates the Actor and applies recover function to all queued messages.
If recover function is not specified then all queues messages are cleared.

Definition Classes
Actor → ActorRef
def toString(): String

Definition Classes
AnyRef → Any
def totalWeight: Int

Definition Classes
Actor → ActorRef
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 whileNotBusy[BAG[_], A](continueIfNonEmpty: Boolean)(releaseFunction: ⇒ A)(implicit bag: Bag[BAG]): BAG[A]

Release function will get executed when the thread was able to set busy to true but busy.set(false) should be invoked by the input releaseFunction similar to *) function under try & finally.
Release function will get executed when the thread was able to set busy to true but busy.set(false) should be invoked by the input releaseFunction similar to *) function under try & finally.
continueIfNonEmpty
will continue executing the function while the queue is non-empty.

Annotations
@inline()

Related Docs: object Actor | package swaydb

class Actor[-T, S] extends ActorRef[T, S] with LazyLogging

Instance Constructors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def ask[R, X[_]](message: (ActorRef[R, Unit]) ⇒ T, delay: FiniteDuration)(implicit bag: Async[X]): Task[R, X]

def ask[R, X[_]](message: (ActorRef[R, Unit]) ⇒ T)(implicit bag: Async[X]): X[R]

def clear(): Unit

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit val executionContext: ExecutionContext

def finalize(): Unit

final def getClass(): Class[_]

def hasMessages: Boolean

def hasRecovery: Boolean

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isNotEmpty: Boolean

def isTerminated: Boolean

lazy val logger: Logger

def messageCount: Int

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onPostTerminate(f: (Actor[T, S]) ⇒ Unit): ActorRef[T, S]

def onPreTerminate(f: (Actor[T, S]) ⇒ Unit): ActorRef[T, S]

def receiveAllForce[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

def recover[M <: T, E](f: (M, IO[E, Actor.Error], Actor[T, S]) ⇒ Unit)(implicit arg0: ExceptionHandler[E]): ActorRef[T, S]

def recoverException[M <: T](f: (M, IO[Throwable, Actor.Error], Actor[T, S]) ⇒ Unit): ActorRef[T, S]

def send(message: T): Unit

def send(message: T, delay: FiniteDuration): TimerTask

val state: S

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

def terminate[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

def terminateAfter(timeout: FiniteDuration): ActorRef[T, S]

def terminateAndClear[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

def terminateAndRecover[BAG[_]]()(implicit bag: Bag[BAG]): BAG[Unit]

def toString(): String

def totalWeight: Int

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whileNotBusy[BAG[_], A](continueIfNonEmpty: Boolean)(releaseFunction: ⇒ A)(implicit bag: Bag[BAG]): BAG[A]

Inherited from LazyLogging

Inherited from ActorRef[T, S]

Inherited from AnyRef

Inherited from Any

Ungrouped