Skip to main content

NoteSequenceCollectionExt

midi_toolkit::sequence

Trait NoteSequenceCollectionExt 

Source 
pub trait NoteSequenceCollectionExt<D: MIDINum, N, Err, I>: Iterator<Item = I> + Sized
where
    N: MIDINote<D>,
    I: Iterator<Item = Result<N, Err>> + Sized,
{
    // Provided method
    fn merge_all(self) -> impl Iterator<Item = Result<N, Err>> { ... }
}

Provided Methods§

Source

fn merge_all(self) -> impl Iterator<Item = Result<N, Err>>

Examples found in repository?
examples/note_chopper.rs (line 50)
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}

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.

Implementors§

Source§

impl<D: MIDINum, N, Err, I, II> NoteSequenceCollectionExt<D, N, Err, I> for II
where N: MIDINote<D>, I: Iterator<Item = Result<N, Err>> + Sized, II: Iterator<Item = I> + Sized,