Struct Delta

pub struct Delta<D: MIDINum, E> {
    pub delta: D,
    pub event: E,
}

Fields

delta: D

event: E

Implementations

impl<D: MIDINum, T> Delta<D, EventBatch<T>>

pub fn into_iter_events(self) -> impl Iterator<Item = Delta<D, T>>

pub fn iter_events(&self) -> impl Iterator<Item = Delta<D, &T>>

impl<D: MIDINum, T> Delta<D, Track<EventBatch<T>>>

pub fn iter_events(&self) -> impl Iterator<Item = Delta<D, Track<&T>>>

Examples found in repository

examples/nps_bench.rs (line 35)

pub fn main() {
    println!("Opening midi...");
    let midi = MIDIFile::open_in_ram(
        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
        None,
    )
    .unwrap();

    let ppq = midi.ppq();
    let merged = pipe!(
        midi.iter_all_track_events_merged_batches()
        |>TimeCaster::<f64>::cast_event_delta()
        |>cancel_tempo_events(250000)
        |>scale_event_time(1.0 / ppq as f64)
        |>unwrap_items()
    );

    println!("Tracks: {}", midi.track_count());

    let start = Instant::now();
    let mut note_count = 0;
    for batch in merged {
        for e in batch.iter_events() {
            if let Event::NoteOn(_) = e.as_event() {
                note_count += 1;
            }
        }
    }

    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
    println!(
        "Notes per second: {}",
        note_count as f64 / start.elapsed().as_secs_f64()
    );
}

impl<D: MIDINum, E> Delta<D, E>

pub fn new(delta: D, event: E) -> Self

Trait Implementations

impl<D: MIDINum, E: BatchTempo> BatchTempo for Delta<D, E>

fn inner_tempo(&self) -> Option<u32>

fn without_tempo(self) -> Option<Self>

impl<D: MIDINum + MIDINumInto<ND>, ND: MIDINum, E> CastEventDelta<ND> for Delta<D, E>

type Output = Delta<ND, E>

fn cast_delta(self) -> Self::Output

impl<D: Clone + MIDINum, E: Clone> Clone for Delta<D, E>

fn clone(&self) -> Delta<D, E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D: Debug + MIDINum, E: Debug> Debug for Delta<D, E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: MIDINum, E> Deref for Delta<D, E>

type Target = E

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<D: MIDINum, E> DerefMut for Delta<D, E>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<D: MIDINum, T> IntoIterator for Delta<D, Track<EventBatch<T>>>

type Item = Delta<D, Track<T>>

The type of the elements being iterated over.

type IntoIter = impl Iterator<Item = Delta<D, Track<T>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<D: MIDINum, E> MIDIDelta<D> for Delta<D, E>

fn delta(&self) -> D

fn delta_mut(&mut self) -> &mut D

fn set_delta(&mut self, delta: D)

impl<D: MIDINum, E: MIDIEventEnum> MIDIEvent for Delta<D, E>

fn key(&self) -> Option<u8>

fn key_mut(&mut self) -> Option<&mut u8>

fn channel(&self) -> Option<u8>

fn channel_mut(&mut self) -> Option<&mut u8>

fn as_u32(&self) -> Option<u32>

impl<D: MIDINum, E: MIDIEventEnum> MIDIEventEnum for Delta<D, E>

fn as_event(&self) -> &Event

fn as_event_mut(&mut self) -> &mut Event

impl<D: PartialEq + MIDINum, E: PartialEq> PartialEq for Delta<D, E>

fn eq(&self, other: &Delta<D, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D: MIDINum, E: SerializeEvent> SerializeEvent for Delta<D, E>

fn serialize_event<T: Write>( &self, buf: &mut T, ) -> Result<usize, MIDIWriteError>

impl<E: SerializeEvent> SerializeEventWithDelta for Delta<u64, E>

fn serialize_delta<T: Write>( &self, buf: &mut T, ) -> Result<usize, MIDIWriteError>

fn serialize_event_with_delta<T: Write>( &self, buf: &mut T, ) -> Result<usize, MIDIWriteError>

impl<D: Eq + MIDINum, E: Eq> Eq for Delta<D, E>

impl<D: MIDINum, E> StructuralPartialEq for Delta<D, E>