coremidi 0.9.0

CoreMIDI library for Rust
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::fmt::Formatter;

use coremidi_sys::MIDIProtocolID;

/// The [MIDI Protocol](https://developer.apple.com/documentation/coremidi/midiprotocolid) to use for messages
///
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Protocol {
    /// MIDI 1.0
    Midi10,

    /// MIDI 2.0
    Midi20,

    /// Reserved for future protocols not known by this crate yet
    /// Please don't use it, unless really needed.
    Unknown(MIDIProtocolID),
}

impl From<MIDIProtocolID> for Protocol {
    fn from(protocol_id: MIDIProtocolID) -> Self {
        match protocol_id as ::std::os::raw::c_uint {
            coremidi_sys::kMIDIProtocol_1_0 => Protocol::Midi10,
            coremidi_sys::kMIDIProtocol_2_0 => Protocol::Midi20,
            _ => Protocol::Unknown(protocol_id),
        }
    }
}

impl From<Protocol> for MIDIProtocolID {
    fn from(protocol: Protocol) -> Self {
        match protocol {
            Protocol::Midi10 => coremidi_sys::kMIDIProtocol_1_0 as MIDIProtocolID,
            Protocol::Midi20 => coremidi_sys::kMIDIProtocol_2_0 as MIDIProtocolID,
            Protocol::Unknown(protocol_id) => protocol_id,
        }
    }
}

impl std::fmt::Debug for Protocol {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Midi10 => write!(f, "MIDI 1.0"),
            Self::Midi20 => write!(f, "MIDI 2.0"),
            Self::Unknown(protocol_id) => write!(f, "Unknown({})", protocol_id),
        }
    }
}

impl std::fmt::Display for Protocol {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        std::fmt::Debug::fmt(self, f)
    }
}

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

    #[test]
    fn from_midi_protocol_id_known() {
        assert_eq!(
            Protocol::from(coremidi_sys::kMIDIProtocol_1_0 as MIDIProtocolID),
            Protocol::Midi10
        );
        assert_eq!(
            Protocol::from(coremidi_sys::kMIDIProtocol_2_0 as MIDIProtocolID),
            Protocol::Midi20
        );
    }

    #[test]
    fn from_midi_protocol_id_unknown() {
        let unknown = Protocol::from(0xFFFF as MIDIProtocolID);
        assert_eq!(unknown, Protocol::Unknown(0xFFFF));
    }

    #[test]
    fn into_midi_protocol_id_roundtrip() {
        let id_10: MIDIProtocolID = Protocol::Midi10.into();
        assert_eq!(Protocol::from(id_10), Protocol::Midi10);

        let id_20: MIDIProtocolID = Protocol::Midi20.into();
        assert_eq!(Protocol::from(id_20), Protocol::Midi20);

        let id_unknown: MIDIProtocolID = Protocol::Unknown(0xBEEF).into();
        assert_eq!(id_unknown, 0xBEEF);
    }

    #[test]
    fn debug_format() {
        assert_eq!(format!("{:?}", Protocol::Midi10), "MIDI 1.0");
        assert_eq!(format!("{:?}", Protocol::Midi20), "MIDI 2.0");
        assert_eq!(format!("{:?}", Protocol::Unknown(99)), "Unknown(99)");
    }

    #[test]
    fn display_format() {
        assert_eq!(format!("{}", Protocol::Midi10), "MIDI 1.0");
        assert_eq!(format!("{}", Protocol::Midi20), "MIDI 2.0");
    }

    #[test]
    fn clone_and_copy() {
        let p = Protocol::Midi20;
        let p2 = p;
        assert_eq!(p, p2);
    }

    #[test]
    fn equality() {
        assert_eq!(Protocol::Midi10, Protocol::Midi10);
        assert_ne!(Protocol::Midi10, Protocol::Midi20);
        assert_ne!(Protocol::Unknown(1), Protocol::Unknown(2));
        assert_eq!(Protocol::Unknown(1), Protocol::Unknown(1));
    }
}