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
|
use std::io;
use std::collections::HashMap;
use std::borrow::Borrow;
use xml::reader;
use xml::reader::{EventReader, XmlEvent};
use xml::attribute::OwnedAttribute;
use std::hash::Hash;
use std::cmp::Eq;
use std::str::FromStr;
use std::fmt::Display;
use failure::Error;
use super::*;
struct AttrMapping(HashMap<String, String>);
impl AttrMapping {
pub fn make(attrs: Vec<OwnedAttribute>) -> AttrMapping {
let mut output = HashMap::new();
for attr in attrs {
output.insert(attr.name.local_name.clone(), attr.value.clone());
}
AttrMapping(output)
}
pub fn get_str<'a, 'b, 'c: 'a, Q: Hash+Eq+Display+?Sized>(&'a self, key: &'b Q, default: &'c str) -> &'a str where String: Borrow<Q> {
self.0.get(key).map(|x| &**x).unwrap_or(default)
}
pub fn req<V: FromStr, Q: Hash+Eq+Display+?Sized>(&self, key: &Q) -> Result<V, Error> where String: Borrow<Q>, V::Err: failure::Fail {
match self.0.get(key){
Some(x) => Ok(x.parse()?),
None => bail!("{} not found in attrs", key)
}
}
pub fn req_midi_pitch<Q: Hash+Eq+Display+?Sized>(&self, key: &Q) -> Result<Pitch, Error> where String: Borrow<Q> {
Ok(Pitch::MIDI(self.req::<f32, Q>(key)?))
}
}
fn parse_note(ev: XmlEvent, into: &mut Vec<Note>) -> Result<bool, Error> {
match ev {
XmlEvent::StartElement{name, attributes, ..} => {
if name.local_name.as_ref() != "note" { bail!("malformed iv: non-note attr in note stream"); }
let attrs = AttrMapping::make(attributes);
into.push(Note {
time: attrs.req("time")?,
ampl: attrs.req("ampl")?,
dur: attrs.req("dur")?,
pitch: attrs.req_midi_pitch("pitch")?,
start_tick: None,
dur_ticks: None
});
Ok(false)
},
_ => Ok(true)
}
}
pub fn read<R: io::Read>(source: R) -> Result<IV, Error> {
let mut output: IV = Default::default();
let mut event_reader = EventReader::new(source);
#[derive(Debug)]
enum ReadState<'a> {
Idle,
InStreams,
InBPMs,
InNoteStream(&'a mut NoteStream),
InAuxStream(&'a mut AuxStream),
}
let mut state = ReadState::Idle;
loop {
match event_reader.next()? {
XmlEvent::StartElement{name, attributes, ..} => {
let attrmap = AttrMapping::make(attributes);
match name.local_name.as_ref() {
"bpms" => { }
"streams" => {
match attrmap.get_str("type", "") {
"ns" => {
let mut notes = Vec::new();
loop {
if !parse_note(event_reader.next()?, &mut notes)? { break; }
}
},
_ => unimplemented!()
}
},
_ => unimplemented!()
}
}
XmlEvent::EndElement{name} => match (name.local_name.as_ref(), &state) {
("bpms", _) => { state = ReadState::Idle; },
("streams", _) => { state = ReadState::Idle; },
_ => (),
},
_ => (),
}
}
Ok(output)
}
|
