services

Service Container for Dependency Injection

Provides a minimal, type-safe service container for injecting optional services into agents without hardcoding dependencies.

Structs

`ServiceContainer`

Minimal service container for dependency injection

Allows agents to accept optional services through clean dependency injection without hardcoding specific service fields in the Agent struct.

Examples

use agent_sdk::services::ServiceContainer;
use std::sync::Arc;

#[derive(Clone)]
struct MyService {
    name: String,
}

let mut container = ServiceContainer::new();
container.register(MyService { name: "test".to_string() });

let service: Option<Arc<MyService>> = container.get();
assert!(service.is_some());

Methods

`new`

fn new() -> Self

Create a new empty service container

`register`

fn register<T>(&mut self, service: T)

Services are stored by their type and can be retrieved later using the same type signature.

Arguments

service - The service instance to register

Examples

# use agent_sdk::services::ServiceContainer;
# #[derive(Clone)]
# struct DatabaseService;
let mut container = ServiceContainer::new();
container.register(DatabaseService);

`get`

fn get<T>(&self) -> Option<Arc<T>>

Get a service from the container

Returns an Arc-wrapped service if found, or None if the service type is not registered.

Returns

Some(Arc<T>) - The service if found
None - If no service of type T is registered

Examples

# use agent_sdk::services::ServiceContainer;
# use std::sync::Arc;
# #[derive(Clone)]
# struct DatabaseService { pub name: String }
# let mut container = ServiceContainer::new();
# container.register(DatabaseService { name: "test".to_string() });
let service: Option<Arc<DatabaseService>> = container.get();
if let Some(db) = service {
    println!("Database: {}", db.name);
}

`has`

fn has<T>(&self) -> bool

Check if a service type is registered

Returns

true - If a service of type T is registered
false - If no service of type T is found

Examples

# use agent_sdk::services::ServiceContainer;
# #[derive(Clone)]
# struct CacheService;
let container = ServiceContainer::new();
assert!(!container.has::<CacheService>());

`len`

fn len(&self) -> usize

Get the number of registered services

`is_empty`

fn is_empty(&self) -> bool

Check if the container is empty

`clear`

fn clear(&mut self)

Remove all services from the container