text stringclasses 1 value
hello world this is a test hello world

🧠 Actory — Typed Actor Model for Rust

actory is a lightweight, strongly typed actor framework for Dart that enables building concurrent, message-driven systems with:

✅ Async & sync actors
✅ Isolate-based concurrency
✅ Typed message passing (no use of dynamic)
✅ Ask/reply patterns with Future-based messaging
✅ Supervision strategies for fault tolerance
✅ Remote actors with WebSocket clustering support
✅ Thread-safe data structures (SafeMap) for shared state

🚀 Basic Usage

final system = ActorSystem();

final greeter = await system.spawn<Greet>(
  Greeter(),
  (msg) => msg as Greet,
);

greeter.send(Greet('Alice'));

🌐 Remote Actors

Actory supports distributed actor systems spanning multiple nodes.

Using `RemoteActorFactory` (Recommended)

final factory = RemoteActorFactory(
  host: 'localhost',
  port: 8080,
  peerUrls: ['ws://localhost:8081'],
);

await factory.start();

await factory.createLocalActor<ChatMessage>(
  'chat-actor',
  ChatActor(),
  (msg) => msg as ChatMessage,
);

factory.registerRemoteActor('remote-chat', 'ws://localhost:8081');

factory.sendMessage('chat-actor', ChatMessage('User', 'Hello!'));
factory.sendMessage('remote-chat', ChatMessage('User', 'Hello remote!'));

Manual Remote Actor Setup

final clusterNode = ClusterNode('localhost', 8080);
final registry = ActorRegistry();

await clusterNode.start();

final localActor = await system.spawn<Message>(actor, decoder);
registry.registerLocal('my-actor', localActor);

registry.registerRemote('remote-actor', 'ws://localhost:8081');

final localRef = registry.get('my-actor');
final remoteRef = registry.get('remote-actor'); // Returns RemoteActorRef

localRef?.send(message);
remoteRef?.send(message);

🔒 SafeMap — Thread-Safe Data Structure

SafeMap provides atomic and thread-safe operations on shared state within a single Dart isolate. Since each actor runs in its own isolate, SafeMap is useful for shared data inside an isolate, while cross-isolate communication should use message passing.

Usage Example

final sharedData = SafeMap<String, String>();

sharedData.set('key', 'value');
final value = sharedData.get('key');

final wasAdded = sharedData.putIfAbsent('key', () => 'default');
final computed = sharedData.getOrCompute('key', () => 'computed');

final wasUpdated = sharedData.updateIfPresent('key', (v) => 'updated_$v');

final keys = sharedData.keys;
final values = sharedData.values;
final entries = sharedData.entries;

final filtered = sharedData.where((key, value) => key.startsWith('user_'));
final transformed = sharedData.map((key, value) => MapEntry('new_$key', value.toUpperCase()));

sharedData.merge({'key2': 'value2'});
sharedData.mergeSafeMap(otherSafeMap);

final copy = sharedData.copy();
final regularMap = sharedData.toMap();
sharedData.clear();

SafeMap in an Actor

class SharedStateActor extends Actor<dynamic> {
  final SafeMap<String, int> _counters = SafeMap<String, int>();
  
  @override
  Future<void> onMessage(dynamic message, ActorContext<dynamic> context) async {
    if (message is IncrementCounter) {
      final current = _counters.get(message.key) ?? 0;
      _counters.set(message.key, current + 1);
      context.send('Counter ${message.key}: ${current + 1}');
    }
  }
}

📁 Examples

/example/main.dart — Basic actor usage
/example/cluster_main.dart — Cluster node example
/example/simple_remote_actor.dart — Simple remote actor
/example/remote_actor_example.dart — Full remote actor demo
/example/factory_remote_actor.dart — RemoteActorFactory usage
/example/safe_map_example.dart — SafeMap usage with actors
/example/safe_map_actor_example.dart — Focused SafeMap actor demo

🔧 Architecture Overview

Actor — Basic message processing unit
ActorSystem — Manages actor lifecycle and supervision
ClusterNode — WebSocket-based cluster node for distributed communication
ActorRegistry — Maps actor IDs to local or remote references
RemoteActorRef — Proxy to communicate with remote actors
RemoteActorFactory — High-level API to manage local and remote actors
SafeMap — Thread-safe map implementation for shared state within isolates