Enum midi_event::Note

#[repr(u8)]pub enum Note {
    C1n,
    Cs1n,
    D1n,
    Ds1n,
    E1n,
    F1n,
    Fs1n,
    G1n,
    Gs1n,
    A1n,
    As1n,
    B1n,
    C0,
    Cs0,
    D0,
    Ds0,
    E0,
    F0,
    Fs0,
    G0,
    Gs0,
    A0,
    As0,
    B0,
    C1,
    Cs1,
    D1,
    Ds1,
    E1,
    F1,
    Fs1,
    G1,
    Gs1,
    A1,
    As1,
    B1,
    C2,
    Cs2,
    D2,
    Ds2,
    E2,
    F2,
    Fs2,
    G2,
    Gs2,
    A2,
    As2,
    B2,
    C3,
    Cs3,
    D3,
    Ds3,
    E3,
    F3,
    Fs3,
    G3,
    Gs3,
    A3,
    As3,
    B3,
    C4,
    Cs4,
    D4,
    Ds4,
    E4,
    F4,
    Fs4,
    G4,
    Gs4,
    A4,
    As4,
    B4,
    C5,
    Cs5,
    D5,
    Ds5,
    E5,
    F5,
    Fs5,
    G5,
    Gs5,
    A5,
    As5,
    B5,
    C6,
    Cs6,
    D6,
    Ds6,
    E6,
    F6,
    Fs6,
    G6,
    Gs6,
    A6,
    As6,
    B6,
    C7,
    Cs7,
    D7,
    Ds7,
    E7,
    F7,
    Fs7,
    G7,
    Gs7,
    A7,
    As7,
    B7,
    C8,
    Cs8,
    D8,
    Ds8,
    E8,
    F8,
    Fs8,
    G8,
    Gs8,
    A8,
    As8,
    B8,
    C9,
    Cs9,
    D9,
    Ds9,
    E9,
    F9,
    Fs9,
    G9,
}

A note representable in a 7 bit unsigned int. The subscript 's' to a note means sharp. The subscript 'n' to an octave means negate, so Cs2n = C# in octave -2.

Because it only uses the least significant 7 bits, any value can be interpreted as either an i8 or a u8 for free (as the representation is the same in both)

This implements both From, Into, From and Into so the names can be completely ignored if prefered

Variants

C1n

Cs1n

D1n

Ds1n

E1n

F1n

Fs1n

G1n

Gs1n

A1n

As1n

B1n

C0

Cs0

D0

Ds0

E0

F0

Fs0

G0

Gs0

A0

Start of 88-note piano keyboard range

As0

B0

C1

Cs1

D1

Ds1

E1

F1

Fs1

G1

Gs1

A1

As1

B1

C2

Start of 5 octave synth range

Cs2

D2

Ds2

E2

F2

Fs2

G2

Gs2

A2

As2

B2

C3

Cs3

D3

Ds3

E3

F3

Fs3

G3

Gs3

A3

As3

B3

C4

Middle C

Cs4

D4

Ds4

E4

F4

Fs4

G4

Gs4

A4

As4

B4

C5

Cs5

D5

Ds5

E5

F5

Fs5

G5

Gs5

A5

As5

B5

C6

Cs6

D6

Ds6

E6

F6

Fs6

G6

Gs6

A6

As6

B6

C7

end of 5 octave synth range

Cs7

D7

Ds7

E7

F7

Fs7

G7

Gs7

A7

As7

B7

C8

end of 88-note piano keyboard range

Cs8

D8

Ds8

E8

F8

Fs8

G8

Gs8

A8

As8

B8

C9

Cs9

D9

Ds9

E9

F9

Fs9

G9

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 Copy for Note

impl Debug for Note

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

Formats the value using the given formatter.

impl Eq for Note

impl From<Note> for u8

fn from(note: Note) -> u8

Performs the conversion.

impl From<Note> for i8

fn from(note: Note) -> Self

Performs the conversion.

impl From<Note> for usize

fn from(note: Note) -> Self

Performs the conversion.

impl From<i8> for Note

fn from(n: i8) -> Note

Performs the conversion.

impl From<u8> for Note

fn from(n: u8) -> Note

Performs the conversion.

impl Hash for Note

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for Note

fn cmp(&self, other: &Note) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl Parse<u8> for Note

fn parse(input: u8) -> Option<Self>

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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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.

#[must_use]fn lt(&self, other: &Rhs) -> bool

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

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

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

#[must_use]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 StructuralEq for Note

impl StructuralPartialEq for Note