Utility classes, extension system, and helper functions for common operations in Akka applications.
Timeout utilities for ask pattern and timed operations.
/**
* Timeout wrapper for duration-based operations
*/
final case class Timeout(duration: FiniteDuration) {
def *(factor: Double): Timeout
def +(other: Timeout): Timeout
def min(other: Timeout): Timeout
def max(other: Timeout): Timeout
}
object Timeout {
implicit def durationToTimeout(duration: FiniteDuration): Timeout = Timeout(duration)
}Immutable byte sequence operations for I/O and data manipulation.
/**
* Immutable byte sequence for efficient I/O operations
*/
abstract class ByteString extends IndexedSeq[Byte] {
def ++(that: ByteString): ByteString
def take(n: Int): ByteString
def drop(n: Int): ByteString
def slice(from: Int, until: Int): ByteString
def utf8String: String
def decodeString(charset: Charset): String
def toArray: Array[Byte]
def asByteBuffer: ByteBuffer
def compact: ByteString
}
object ByteString {
def apply(bytes: Byte*): ByteString
def apply(array: Array[Byte]): ByteString
def apply(string: String): ByteString
def apply(string: String, charset: String): ByteString
def fromArray(array: Array[Byte]): ByteString
def fromString(string: String): ByteString
def empty: ByteString
}System extension mechanism for adding functionality to ActorSystem.
/**
* Extension base trait
*/
trait Extension
/**
* Extension identifier
*/
trait ExtensionId[T <: Extension] {
def createExtension(system: ExtendedActorSystem): T
def apply(system: ActorSystem): T
def lookup(): ExtensionId[T]
}
/**
* Extension ID provider
*/
trait ExtensionIdProvider {
def lookup(): ExtensionId[_ <: Extension]
}Usage Examples:
import akka.actor.{Extension, ExtensionId, ExtensionIdProvider, ExtendedActorSystem}
// Define a custom extension
class CounterExtension(system: ExtendedActorSystem) extends Extension {
private var count = 0
def increment(): Int = {
count += 1
count
}
def current: Int = count
}
object CounterExtension extends ExtensionId[CounterExtension] with ExtensionIdProvider {
def createExtension(system: ExtendedActorSystem): CounterExtension =
new CounterExtension(system)
def lookup() = CounterExtension
}
// Usage
val system = ActorSystem("ExtensionExample")
val counter = CounterExtension(system)
val count1 = counter.increment() // 1
val count2 = counter.increment() // 2Task scheduling for delayed and periodic operations.
/**
* Scheduler for delayed and periodic task execution
*/
trait Scheduler {
def scheduleOnce(delay: FiniteDuration, runnable: Runnable)(implicit executor: ExecutionContext): Cancellable
def scheduleOnce(delay: FiniteDuration, receiver: ActorRef, message: Any)(implicit executor: ExecutionContext, sender: ActorRef = Actor.noSender): Cancellable
def scheduleWithFixedDelay(initialDelay: FiniteDuration, delay: FiniteDuration)(runnable: Runnable)(implicit executor: ExecutionContext): Cancellable
def scheduleAtFixedRate(initialDelay: FiniteDuration, interval: FiniteDuration)(runnable: Runnable)(implicit executor: ExecutionContext): Cancellable
}
/**
* Cancellable scheduled task
*/
trait Cancellable {
def cancel(): Boolean
def isCancelled: Boolean
}