Struct musical_note::Note

pub struct Note { /* private fields */ }

Not yet resolved Note, constructed by MIDI.

Implementations

impl Note

pub fn from_midi(midi: u8, accidental: Option<Accidental>) -> Self

Examples found in repository

src/lib.rs (line 234)

pub fn midi_to_note(midi: u8, key: Key, accidental: Option<Accidental>) -> ResolvedNote {
    Note::from_midi(midi, accidental).resolve(key)
}

/// Not yet resolved Note, constructed by MIDI.
#[derive(Debug, PartialEq, PartialOrd, Clone, Copy, Serialize, Deserialize)]
pub struct Note {
    midi: u8,
    accidental: Option<Accidental>,
    octave: Octave,
}
impl Note {
    pub fn from_midi(midi: u8, accidental: Option<Accidental>) -> Self {
        Self {
            midi,
            accidental,
            octave: Octave::from_midi(midi),
        }
    }
    pub fn resolve(&self, key: Key) -> ResolvedNote {
        let (midi_note, octave) = Octave::split_midi(self.midi);
        // let midi_note = self.midi % 12;
        let notes_map = NotesMap::get();
        let res = self.resolve_by_accident(&notes_map, midi_note, octave);
        if res.is_some() {
            return res.unwrap();
        }
        let scale = key.resolve_scale(&notes_map);

        scale.resolve_pitch(notes_map, midi_note, octave)
    }
    fn resolve_by_accident(
        &self,
        notes_map: &NotesMap,
        midi_note: u8,
        octave: Octave,
    ) -> Option<ResolvedNote> {
        if self.accidental.is_some() {
            let acc = self.accidental.as_ref().unwrap();
            let note = notes_map.get_by_midi(&midi_note).get(&acc);
            if note.is_some() {
                return Some(ResolvedNote::new(
                    note.unwrap().clone(),
                    acc.clone(),
                    octave,
                    octave.apply_to_midi_note(midi_note),
                ));
            }
        }
        None
    }
    pub fn midi(&self) -> u8 {
        self.midi
    }
    pub fn set_midi(&mut self, midi: u8) {
        self.midi = midi;
    }
    pub fn accidental(&self) -> Option<Accidental> {
        self.accidental.clone()
    }
    pub fn set_accidental(&mut self, accidental: Option<Accidental>) {
        self.accidental = accidental;
    }
}
impl From<u8> for Note {
    /// from midi, but without boilerplate.
    fn from(midi: u8) -> Self {
        Self::from_midi(midi, None)
    }

pub fn resolve(&self, key: Key) -> ResolvedNote

Examples found in repository

src/lib.rs (line 234)

pub fn midi_to_note(midi: u8, key: Key, accidental: Option<Accidental>) -> ResolvedNote {
    Note::from_midi(midi, accidental).resolve(key)
}

pub fn midi(&self) -> u8

pub fn set_midi(&mut self, midi: u8)

pub fn accidental(&self) -> Option<Accidental>

pub fn set_accidental(&mut self, accidental: Option<Accidental>)

Trait Implementations

impl Clone for Note

fn clone(&self) -> Note

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Note

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Note

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ResolvedNote> for Note

fn from(value: ResolvedNote) -> Self

Converts to this type from the input type.

impl From<u8> for Note

fn from(midi: u8) -> Self

from midi, but without boilerplate.

impl PartialEq<Note> for Note

fn eq(&self, other: &Note) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<Note> for Note

fn partial_cmp(&self, other: &Note) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Note

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Note

impl StructuralPartialEq for Note