pub trait ResultIterExt<T, Err>: Iterator<Item = Result<T, Err>> + Sized {
// Provided methods
fn unwrap_items(self) -> impl Iterator<Item = T>
where T: Debug,
Err: Debug { ... }
fn collect_vec_result(self) -> Result<Vec<T>, Err> { ... }
}Provided Methods§
Sourcefn unwrap_items(self) -> impl Iterator<Item = T>
fn unwrap_items(self) -> impl Iterator<Item = T>
Examples found in repository?
examples/test.rs (line 16)
9pub fn main() {
10 println!("Opening midi...");
11 let file = MIDIFile::open("/run/media/d/Midis/The Quarantine Project.mid", None).unwrap();
12 let now = Instant::now();
13 let mut nc: u64 = 0;
14
15 println!("Creating parsers...");
16 let merged = file.iter_all_track_events_merged().unwrap_items();
17 println!("Parsing midi...");
18
19 for e in merged {
20 if let Event::NoteOn(_) = e.as_event() {
21 nc += 1;
22 }
23 }
24
25 println!("Finished parsing midi, found {nc} notes");
26 println!("Elapsed {:?}", now.elapsed());
27 println!(
28 "Notes/second {}",
29 (nc as f64 / now.elapsed().as_secs_f64()).round()
30 );
31}More examples
examples/polyphony.rs (line 11)
5pub fn main() {
6 println!("Opening midi...");
7 let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
8 println!("Parsing midi...");
9 let now = Instant::now();
10 let mut poly: u64 = 0;
11 let merged = file.iter_all_tracks().merge_all().unwrap_items();
12
13 let mut max_poly: u64 = 0;
14
15 for e in merged {
16 match *e {
17 Event::NoteOn(_) => {
18 poly += 1;
19 if poly > max_poly {
20 max_poly = poly;
21 }
22 }
23 Event::NoteOff(_) => poly -= 1,
24 _ => {}
25 }
26 }
27
28 println!("Finished parsing midi, found {max_poly} polyphony");
29 println!("Elapsed {:?}", now.elapsed());
30}examples/nps_bench.rs (line 23)
9pub fn main() {
10 println!("Opening midi...");
11 let midi = MIDIFile::open_in_ram(
12 "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
13 None,
14 )
15 .unwrap();
16
17 let ppq = midi.ppq();
18 let merged = midi
19 .iter_all_track_events_merged_batches()
20 .cast_event_delta::<f64>()
21 .cancel_tempo_events(250000)
22 .scale_event_time(1.0 / ppq as f64)
23 .unwrap_items();
24
25 println!("Tracks: {}", midi.track_count());
26
27 let start = Instant::now();
28 let mut note_count = 0;
29 for batch in merged {
30 for e in batch.iter_events() {
31 if let Event::NoteOn(_) = e.as_event() {
32 note_count += 1;
33 }
34 }
35 }
36
37 println!("Note count: {} \tTime: {:?}", note_count, start.elapsed());
38 println!(
39 "Notes per second: {}",
40 note_count as f64 / start.elapsed().as_secs_f64()
41 );
42}examples/write.rs (line 22)
9pub fn main() {
10 println!("Opening midi...");
11 let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
12 let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
13 println!("Parsing midi...");
14 let now = Instant::now();
15
16 let mut nc: u64 = 0;
17 {
18 let mut track_writer = writer.try_open_next_track().unwrap();
19 // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
20 let converted = file.iter_all_tracks();
21 // .map(|track| pipe!(track|>events_to_notes()|>notes_to_events()));
22 let merged = converted.merge_all().unwrap_items();
23 for e in merged {
24 if let Event::NoteOn(_) = *e {
25 nc += 1
26 }
27 track_writer.write_event(e).unwrap();
28 }
29 }
30
31 println!("Finished parsing midi, found {nc} notes");
32 println!("Elapsed {:?}", now.elapsed());
33 println!(
34 "Notes/second {}",
35 (nc as f64 / now.elapsed().as_secs_f64()).round()
36 );
37}examples/events_notes.rs (line 22)
5pub fn main() {
6 println!("Opening midi...");
7 let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();
8 println!("Parsing midi...");
9 let now = Instant::now();
10 let mut nc: u64 = 0;
11 // for track in file.iter_all_tracks(true) {
12 // // let track = TimeCaster::<f64>::cast_event_delta(track);
13 // for e in pipe!(track|>unwrap_items())
14 // // for e in pipe!(track|>TimeCaster::<f64>::cast_event_delta()|>scale_event_time(10.0)|>unwrap_items())
15 // {
16 // match e {
17 // Event::NoteOn(_) => nc += 1,
18 // _ => {}
19 // }
20 // }
21 // }
22 let merged = file.iter_all_tracks().merge_all().unwrap_items();
23
24 for e in merged {
25 if let Event::NoteOn(_) = *e {
26 nc += 1
27 }
28 let delta = e.delta;
29 if delta > 184467440737 {
30 dbg!(e);
31 }
32 }
33
34 println!("Finished parsing midi, found {nc} notes");
35 println!("Elapsed {:?}", now.elapsed());
36 println!(
37 "Notes/second {}",
38 (nc as f64 / now.elapsed().as_secs_f64()).round()
39 );
40}examples/note_chopper.rs (line 48)
29fn main() {
30 let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();
31
32 let chop_size = file.ppq() as u64 / 16;
33
34 let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
35
36 for (i, track) in file.iter_all_tracks().enumerate() {
37 println!("Chopping track {} of {}", i, file.track_count());
38
39 let cached = track.collect_vec_result().unwrap();
40
41 let non_note_events = cached.iter().cloned().into_ok().filter_non_note_events();
42
43 let notes = cached
44 .iter()
45 .cloned()
46 .into_ok()
47 .events_to_notes()
48 .unwrap_items();
49 let chopped = notes.map(|n| chop_note(n, chop_size).into_ok());
50 let flattened = chopped.merge_all().notes_to_events();
51
52 // let notes = pipe!(cached.iter().cloned()|>wrap_ok()|>events_to_notes()|>unwrap_items());
53 // let flattened = pipe!(notes|>wrap_ok()|>notes_to_events());
54
55 let merged = merge_events(flattened, non_note_events);
56
57 writer
58 .try_open_next_track()
59 .unwrap()
60 .write_events_iter(merged.unwrap_items())
61 .unwrap();
62 }
63}Additional examples can be found in:
Sourcefn collect_vec_result(self) -> Result<Vec<T>, Err>
fn collect_vec_result(self) -> Result<Vec<T>, Err>
Examples found in repository?
examples/note_chopper.rs (line 39)
29fn main() {
30 let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();
31
32 let chop_size = file.ppq() as u64 / 16;
33
34 let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
35
36 for (i, track) in file.iter_all_tracks().enumerate() {
37 println!("Chopping track {} of {}", i, file.track_count());
38
39 let cached = track.collect_vec_result().unwrap();
40
41 let non_note_events = cached.iter().cloned().into_ok().filter_non_note_events();
42
43 let notes = cached
44 .iter()
45 .cloned()
46 .into_ok()
47 .events_to_notes()
48 .unwrap_items();
49 let chopped = notes.map(|n| chop_note(n, chop_size).into_ok());
50 let flattened = chopped.merge_all().notes_to_events();
51
52 // let notes = pipe!(cached.iter().cloned()|>wrap_ok()|>events_to_notes()|>unwrap_items());
53 // let flattened = pipe!(notes|>wrap_ok()|>notes_to_events());
54
55 let merged = merge_events(flattened, non_note_events);
56
57 writer
58 .try_open_next_track()
59 .unwrap()
60 .write_events_iter(merged.unwrap_items())
61 .unwrap();
62 }
63}More examples
examples/benchmark.rs (line 43)
32fn main() {
33 let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
34 let repeats = 4;
35
36 println!("Opening midi...");
37 let file = MIDIFile::open(filename, None).unwrap();
38
39 println!("Tracks: {}", file.track_count());
40
41 let loaded_tracks = file
42 .iter_all_tracks()
43 .map(|t| t.collect_vec_result().unwrap())
44 .collect::<Vec<_>>();
45
46 let mut nc: u64 = 0;
47 for track in loaded_tracks.iter() {
48 for e in track {
49 if let Event::NoteOn(_) = **e {
50 nc += 1
51 }
52 }
53 }
54 println!("Note count: {nc}");
55
56 do_run("Parse all tracks individually", repeats, || {
57 for track in file.iter_all_tracks() {
58 for _ in track {}
59 }
60 });
61 do_run("Merge all tracks together while parsing", repeats, || {
62 let merged = file.iter_all_tracks().merge_all();
63 for _ in merged {}
64 });
65 do_run("Clone all events", repeats, || {
66 let iters = loaded_tracks.iter().map(|t| t.iter().cloned());
67 for track in iters {
68 for _ in track {}
69 }
70 });
71 do_run(
72 "Clone all events, then wrap and unwrap them in Result",
73 repeats,
74 || {
75 let iters = loaded_tracks
76 .iter()
77 .map(|t| t.iter().cloned().into_ok().unwrap_items());
78 for track in iters {
79 for _ in track {}
80 }
81 },
82 );
83 do_run("Merge all tracks together while cloning", repeats, || {
84 let iters = loaded_tracks
85 .iter()
86 .map(|t| t.iter().cloned().into_ok())
87 .collect::<Vec<_>>();
88 let merged = iters.into_iter().merge_all();
89 for _ in merged {}
90 });
91 do_run("Write each track while cloning", repeats, || {
92 let output = Cursor::new(Vec::<u8>::new());
93 let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
94
95 let iters = loaded_tracks.iter().map(|t| t.iter().cloned());
96 for track in iters {
97 let mut track_writer = writer.try_open_next_track().unwrap();
98 for e in track {
99 track_writer.write_event(e).unwrap();
100 }
101 }
102 });
103 do_run("Merge each track while cloning then write", repeats, || {
104 let output = Cursor::new(Vec::<u8>::new());
105 let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
106
107 let iters = loaded_tracks
108 .iter()
109 .map(|t| t.iter().cloned().into_ok())
110 .collect::<Vec<_>>();
111 let merged = iters.into_iter().merge_all().unwrap_items();
112 let mut track_writer = writer.try_open_next_track().unwrap();
113 for e in merged {
114 track_writer.write_event(e).unwrap();
115 }
116 });
117}Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.