midix 3.2.0

MIDI structures designed for humans
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#![doc = r#"
Contains all possible message types per MIDI 1.0

There are five total message types. The layout looks like this:
- [`MidiMessage`]
    - [`SystemMessage`]
        - [`SystemCommonMessage`]
        - [`SystemRealTimeMessage`]
        - [`SystemExclusiveMessage`]
    - [`ChannelMessage`]
        - [`ChannelVoiceMessage`]
        - [`ChannelModeMessage`]

# Hierarchy
```text
                |--------------|
                | MIDI Message |
                |--------------|
                 /            \
|-----------------|          |----------------|
| Channel Message |          | System Message |
|-----------------|          |----------------|
```

```text
                |--------------------------|
                |      System Message      |
                |--------------------------|
                 /           |            \
|----------------| |-------------------| |-------------------|
| Common Message | | Real-time Message | | Exclusive Message |
|----------------| |-------------------| |-------------------|
```

```text
                |-----------------|
                | Channel Message |
                |-----------------|
                 /               \
|-----------------------|   |----------------------|
| Channel Voice Message |   | Channel Mode Message |
|-----------------------|   |----------------------|
```

"#]

pub mod channel;
pub use channel::*;
pub mod system;
pub use system::*;

#[doc = r#"
An enumeration of all possible midi messages
"#]
#[derive(Debug)]
pub enum MidiMessage<'a> {
    /// A system common message
    SysCommon(SystemCommonMessage<'a>),

    /// A system real-time message
    SysRealTime(SystemRealTimeMessage),

    /// A system exclusive message
    SysExclusive(SystemExclusiveMessage<'a>),

    /// A channel voice message
    ChannelVoice(ChannelVoiceMessage),

    /// A channel mode message
    ChannelMode(ChannelModeMessage),
}

impl<'a> From<SystemMessage<'a>> for MidiMessage<'a> {
    fn from(value: SystemMessage<'a>) -> Self {
        match value {
            SystemMessage::Common(c) => MidiMessage::SysCommon(c),
            SystemMessage::Exclusive(e) => MidiMessage::SysExclusive(e),
            SystemMessage::RealTime(r) => MidiMessage::SysRealTime(r),
        }
    }
}

impl From<ChannelMessage> for MidiMessage<'_> {
    fn from(value: ChannelMessage) -> Self {
        match value {
            ChannelMessage::Mode(m) => MidiMessage::ChannelMode(m),
            ChannelMessage::Voice(v) => MidiMessage::ChannelVoice(v),
        }
    }
}
impl<'a> From<SystemCommonMessage<'a>> for MidiMessage<'a> {
    fn from(value: SystemCommonMessage<'a>) -> Self {
        Self::SysCommon(value)
    }
}

impl From<SystemRealTimeMessage> for MidiMessage<'_> {
    fn from(value: SystemRealTimeMessage) -> Self {
        Self::SysRealTime(value)
    }
}

impl<'a> From<SystemExclusiveMessage<'a>> for MidiMessage<'a> {
    fn from(value: SystemExclusiveMessage<'a>) -> Self {
        Self::SysExclusive(value)
    }
}

impl From<ChannelVoiceMessage> for MidiMessage<'_> {
    fn from(value: ChannelVoiceMessage) -> Self {
        Self::ChannelVoice(value)
    }
}

impl From<ChannelModeMessage> for MidiMessage<'_> {
    fn from(value: ChannelModeMessage) -> Self {
        Self::ChannelMode(value)
    }
}