pocketstation 1.0.0

Source-aware desktop audio Session SDK
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

//! Setup-time ownership produced from one compiled Session.

#[cfg(any(test, feature = "internal-testing"))]
use crate::frame::{RouteId, SessionId};
use crate::runtime::{PlanRunnerCancellation, PlanSourceInput, RealtimePlanExecutor};
use crate::session::SessionSpec;

use super::{
    PreparedExternalSourceMapping, PreparedOperatorMapping, PreparedSourceMapping,
    PreparedWorkerMapping,
};

/// Setup-time ownership for one compiled Session.
///
/// Preparation instantiates the realtime plan and allocates only bounded
/// channels. It does not open capture, start endpoint workers, spawn a runtime
/// thread, or publish a `Running` lifecycle state.
pub struct PreparedSession {
    pub(crate) spec: SessionSpec,
    pub(crate) executor: RealtimePlanExecutor,
    pub(crate) source_mappings: Vec<PreparedSourceMapping>,
    pub(crate) source_inputs: Vec<PlanSourceInput>,
    pub(crate) worker_mappings: Vec<PreparedWorkerMapping>,
    pub(crate) operator_mappings: Vec<PreparedOperatorMapping>,
    pub(crate) external_source_mappings: Vec<PreparedExternalSourceMapping>,
    pub(crate) cancellation: PlanRunnerCancellation,
}

impl PreparedSession {
    #[cfg(any(test, feature = "internal-testing"))]
    pub const fn session_id(&self) -> SessionId {
        self.spec.session_id()
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn spec(&self) -> &SessionSpec {
        &self.spec
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn source_mappings(&self) -> &[PreparedSourceMapping] {
        &self.source_mappings
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn source_input_count(&self) -> usize {
        self.source_inputs.len()
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn worker_mappings(&self) -> &[PreparedWorkerMapping] {
        &self.worker_mappings
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn operator_mappings(&self) -> &[PreparedOperatorMapping] {
        &self.operator_mappings
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn route_observations(
        &self,
        route_id: RouteId,
    ) -> Option<crate::runtime::EdgeObservations> {
        let mapping = self
            .worker_mappings
            .iter()
            .find(|mapping| mapping.route_id == route_id)?;
        self.executor.observations(mapping.receiver.edge_id())
    }

    #[cfg(any(test, feature = "internal-testing"))]
    pub fn cancellation_requested(&self) -> bool {
        self.cancellation.is_requested()
    }
}