Struct Database 

pub struct Database<A: RuntimeAdapter + Spawn + 'static> { /* private fields */ }

AimDB Database implementation

Unified database combining runtime adapter management with type-safe record registration and producer-consumer patterns. See examples/ for usage patterns.

This is a thin wrapper around AimDb<R> that adds adapter-specific functionality. Most users should use AimDbBuilder directly to create databases.

Implementations

impl<A: RuntimeAdapter + Spawn + 'static> Database<A>

pub fn new(adapter: A, aimdb: AimDb<A>) -> DbResult<Self>

Creates a new database from adapter and AimDb

Arguments

• adapter - The runtime adapter
• aimdb - The configured AimDb instance

Most users should use AimDbBuilder directly instead of this constructor.

pub fn adapter(&self) -> &A

Gets a reference to the runtime adapter

Example

let adapter = db.adapter();
// Use adapter directly

pub async fn produce<T>(&self, key: impl AsRef<str>, data: T) -> DbResult<()>

where T: Send + 'static + Clone + Debug,

Produces typed data to a specific record by key

Example

db.produce("sensor.temp", SensorData { temp: 23.5 }).await?;

pub fn subscribe<T>( &self, key: impl AsRef<str>, ) -> DbResult<Box<dyn BufferReader<T> + Send>>

where T: Send + Sync + 'static + Debug + Clone,

Subscribes to a record by key

Creates a subscription to the configured buffer for the given record key. Returns a boxed reader for receiving values asynchronously.

Example

let mut reader = db.subscribe::<SensorData>("sensor.temp")?;

loop {
    match reader.recv().await {
        Ok(data) => println!("Received: {:?}", data),
        Err(e) => {
            eprintln!("Error: {:?}", e);
            break;
        }
    }
}

pub fn context(&self) -> RuntimeContext<A>

where A: Runtime + Clone,

Creates a RuntimeContext for this database

Provides services with access to runtime capabilities (timing, logging) plus the emitter.

Example

let ctx = db.context();
// Pass ctx to services

impl<A> Database<A>

where A: RuntimeAdapter + Spawn,

pub fn spawn<F>(&self, future: F) -> DbResult<()>

where F: Future<Output = ()> + Send + 'static,

Spawns a service on the database’s runtime

Example

async fn my_service<R: Runtime>(ctx: aimdb_core::RuntimeContext<R>) -> aimdb_core::DbResult<()> {
    // Service implementation
    Ok(())
}

let ctx = db.context();
db.spawn(async move {
    if let Err(e) = my_service(ctx).await {
        eprintln!("Service error: {:?}", e);
    }
})?;