mockforge-world-state 0.3.145

World State Engine - Unified visualization of all MockForge state systems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//! Time Aggregator - Collect time/temporal state into world state
//!
//! This aggregator collects virtual clock state, scheduled events, and
//! time scale information from the time travel subsystem.

use crate::aggregators::StateAggregator;
use crate::model::{NodeType, StateEdge, StateLayer, StateNode};
use async_trait::async_trait;
use mockforge_core::time_travel::VirtualClock;
use std::sync::Arc;

/// Aggregator for time/temporal state
pub struct TimeAggregator {
    /// Virtual clock (if available)
    virtual_clock: Option<Arc<VirtualClock>>,
}

impl TimeAggregator {
    /// Create a new time aggregator
    pub fn new(virtual_clock: Option<Arc<VirtualClock>>) -> Self {
        Self { virtual_clock }
    }
}

#[async_trait]
impl StateAggregator for TimeAggregator {
    async fn aggregate(&self) -> anyhow::Result<(Vec<StateNode>, Vec<StateEdge>)> {
        let mut nodes = Vec::new();
        let edges = Vec::new();

        if let Some(ref clock) = self.virtual_clock {
            let mut time_node = StateNode::new(
                "time:virtual_clock".to_string(),
                "Virtual Clock".to_string(),
                NodeType::System,
                StateLayer::Time,
            );

            let now = clock.now();
            let enabled = clock.is_enabled();
            let scale = clock.get_scale();

            time_node.set_property("enabled".to_string(), serde_json::json!(enabled));
            time_node.set_property("current_time".to_string(), serde_json::json!(now.to_rfc3339()));
            time_node.set_property("scale_factor".to_string(), serde_json::json!(scale));

            if enabled {
                time_node.set_state("enabled".to_string());
            } else {
                time_node.set_state("disabled".to_string());
            }

            nodes.push(time_node);
        }

        Ok((nodes, edges))
    }

    fn layer(&self) -> StateLayer {
        StateLayer::Time
    }
}