sim-lib-stream-device 0.1.1

Hardware-free device sample contracts for SIM stream sources.
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Deterministic modeled device sample sources.

use sim_kernel::Symbol;

use crate::{DeviceCaps, DeviceSample};

/// A deterministic sample source driven entirely by an integer index.
///
/// Implementations must not read clocks, random sources, hardware, network, or
/// process state. The same source and index must always produce the same sample.
pub trait ModeledSource {
    /// Sample type emitted by the source.
    type Sample: DeviceSample;

    /// Returns the sample for `index`.
    fn at(&self, index: u64) -> Self::Sample;
}

/// Reports whether a modeled source's sequence numbers are monotone.
pub fn seq_is_monotone<S: ModeledSource>(source: &S, start: u64, count: usize) -> bool {
    let mut previous = None;
    for offset in 0..count {
        let Some(index) = start.checked_add(offset as u64) else {
            return false;
        };
        let seq = source.at(index).seq();
        if previous.is_some_and(|previous| previous > seq) {
            return false;
        }
        previous = Some(seq);
    }
    true
}

/// Deterministic source for the base [`DeviceCaps`] sample.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ModeledDeviceCapsSource {
    device: Symbol,
    streams: Vec<Symbol>,
    inputs: Vec<Symbol>,
    outputs: Vec<Symbol>,
    seq_base: u64,
}

impl ModeledDeviceCapsSource {
    /// Builds a modeled capabilities source.
    pub fn new(
        device: Symbol,
        streams: Vec<Symbol>,
        inputs: Vec<Symbol>,
        outputs: Vec<Symbol>,
    ) -> Self {
        Self {
            device,
            streams,
            inputs,
            outputs,
            seq_base: 0,
        }
    }

    /// Sets the sequence number emitted at index zero.
    pub fn with_seq_base(mut self, seq_base: u64) -> Self {
        self.seq_base = seq_base;
        self
    }

    /// Builds the deterministic demo source used by tests and docs.
    pub fn demo() -> Self {
        Self::new(
            Symbol::qualified("device", "modeled-edge"),
            vec![
                Symbol::qualified("device/stream", "battery"),
                Symbol::qualified("device/stream", "motion"),
            ],
            vec![Symbol::qualified("device/input", "button")],
            vec![
                Symbol::qualified("device/output", "screen"),
                Symbol::qualified("device/output", "haptic"),
            ],
        )
    }
}

impl ModeledSource for ModeledDeviceCapsSource {
    type Sample = DeviceCaps;

    fn at(&self, index: u64) -> Self::Sample {
        DeviceCaps::new(
            self.seq_base.saturating_add(index),
            self.device.clone(),
            self.streams.clone(),
            self.inputs.clone(),
            self.outputs.clone(),
        )
    }
}