tessl/maven-com-typesafe-akka--akka-actor-2-13

Akka Actor library - a toolkit for building highly concurrent, distributed, and resilient message-driven applications for Java and Scala using the Actor Model.

Overview

Eval results

Files

Utilities and Extensions

Name: tessl/maven-com-typesafe-akka--akka-actor-2-13
Author: tessl

Utility classes, extension system, and helper functions for common operations in Akka applications.

Capabilities

Timeout Support

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)
}

ByteString Operations

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
}

Extension System

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() // 2

Scheduler

Task 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
}

Install with Tessl CLI

npx tessl i tessl/maven-com-typesafe-akka--akka-actor-2-13

docs