Struct NamespacedMemory 

pub struct NamespacedMemory { /* private fields */ }

Namespaced memory wrapper providing isolation and TTL support

Architecture

┌─────────────────────────────────────────┐
│      NamespacedMemory                   │
├─────────────────────────────────────────┤
│  Namespace: "market"                    │
│    - btc_price → $43,200 (TTL: 5m)     │
│    - eth_price → $2,300  (TTL: 5m)     │
├─────────────────────────────────────────┤
│  Namespace: "news"                      │
│    - latest → "Fed announces..." (TTL: 1h) │
├─────────────────────────────────────────┤
│  Namespace: "analysis"                  │
│    - btc_signal → "BUY" (TTL: 30m)     │
└─────────────────────────────────────────┘

Benefits

• Isolation: Each namespace is independent
• TTL: Automatic expiration of stale data
• Performance: Shared data avoids redundant computation
• Security: Namespaces prevent cross-contamination

Implementations

impl NamespacedMemory

pub fn new(memory: Arc<MemoryManager>) -> Self

Create a new namespaced memory wrapper

pub async fn store( &self, namespace: &str, key: &str, value: &str, ttl: Option<Duration>, author: Option<String>, ) -> Result<()>

Store a value in a specific namespace with optional TTL

Arguments

• namespace - Namespace for isolation (e.g., “market”, “news”, “analysis”)
• key - Unique key within the namespace
• value - Value to store
• ttl - Optional time-to-live duration
• author - Optional author/source identifier

Example

// Store market price with 5-minute TTL
memory.store(
    "market",
    "btc_price",
    "$43,200",
    Some(Duration::from_secs(300)),
    Some("PriceAPI")
).await?;

pub async fn read(&self, namespace: &str, key: &str) -> Result<Option<String>>

Read a value from a specific namespace

Returns None if:

• Key doesn’t exist
• Entry has expired

Example

if let Some(price) = memory.read("market", "btc_price").await? {
    println!("BTC price: {}", price);
} else {
    println!("Price not available or expired");
}

pub async fn read_with_metadata( &self, namespace: &str, key: &str, ) -> Result<Option<MemoryEntry>>

Read with metadata (including timestamp, author, etc.)

pub async fn list_keys(&self, namespace: &str) -> Result<Vec<String>>

List all keys in a namespace

pub async fn delete(&self, namespace: &str, key: &str) -> Result<()>

Delete a key from a namespace

pub async fn clear_namespace(&self, namespace: &str) -> Result<()>

Clear all entries in a namespace