oaat-core 0.1.3

Core types, wire format, and protocol messages for OAAT (Open Advanced Audio Transport)
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

use crate::error::OaatError;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionState {
    Discovery,
    Handshake,
    Idle,
    Negotiation,
    Streaming,
    Paused,
    Stopped,
    Disconnected,
}

impl SessionState {
    pub fn can_transition_to(self, next: Self) -> bool {
        use SessionState::*;
        matches!(
            (self, next),
            (Discovery, Handshake)
                | (Handshake, Idle)
                | (Handshake, Disconnected)
                | (Idle, Negotiation)
                | (Idle, Disconnected)
                | (Negotiation, Streaming)
                | (Negotiation, Idle)
                | (Negotiation, Disconnected)
                | (Streaming, Paused)
                | (Streaming, Stopped)
                | (Streaming, Disconnected)
                | (Paused, Streaming)
                | (Paused, Stopped)
                | (Paused, Disconnected)
                | (Stopped, Negotiation)
                | (Stopped, Idle)
                | (Stopped, Disconnected)
                | (Disconnected, Discovery)
        )
    }

    pub fn transition(self, next: Self) -> Result<Self, OaatError> {
        if self.can_transition_to(next) {
            Ok(next)
        } else {
            Err(OaatError::InvalidStateTransition {
                from: self,
                to: next,
            })
        }
    }
}

impl std::fmt::Display for SessionState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Discovery => write!(f, "Discovery"),
            Self::Handshake => write!(f, "Handshake"),
            Self::Idle => write!(f, "Idle"),
            Self::Negotiation => write!(f, "Negotiation"),
            Self::Streaming => write!(f, "Streaming"),
            Self::Paused => write!(f, "Paused"),
            Self::Stopped => write!(f, "Stopped"),
            Self::Disconnected => write!(f, "Disconnected"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn valid_transitions() {
        let s = SessionState::Discovery;
        let s = s.transition(SessionState::Handshake).unwrap();
        let s = s.transition(SessionState::Idle).unwrap();
        let s = s.transition(SessionState::Negotiation).unwrap();
        let s = s.transition(SessionState::Streaming).unwrap();
        let s = s.transition(SessionState::Paused).unwrap();
        let s = s.transition(SessionState::Streaming).unwrap();
        let s = s.transition(SessionState::Stopped).unwrap();
        let s = s.transition(SessionState::Disconnected).unwrap();
        assert_eq!(s, SessionState::Disconnected);
    }

    #[test]
    fn invalid_transition() {
        let s = SessionState::Idle;
        assert!(s.transition(SessionState::Streaming).is_err());
    }
}