Enum toio::Note

#[repr(u8)]pub enum Note {
    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,
    GS9,
    A9,
    AS9,
    B9,
    C10,
    CS10,
    D10,
    DS10,
    E10,
    F10,
    FS10,
    G10,
    NoSound,
}

Sound note.

Variants

C0

C 0

CS0

C# 0

D0

D 0

DS0

D# 0

E0

E 0

F0

F 0

FS0

F# 0

G0

G 0

GS0

G# 0

A0

A 0

AS0

A# 0

B0

B 0

C1

C 1

CS1

C# 1

D1

D 1

DS1

D# 1

E1

E 1

F1

F 1

FS1

F# 1

G1

G 1

GS1

G# 1

A1

A 1

AS1

A# 1

B1

B 1

C2

C 2

CS2

C# 2

D2

D 2

DS2

D# 2

E2

E 2

F2

F 2

FS2

F# 2

G2

G 2

GS2

G# 2

A2

A 2

AS2

A# 2

B2

B 2

C3

C 3

CS3

C# 3

D3

D 3

DS3

D# 3

E3

E 3

F3

F 3

FS3

F# 3

G3

G 3

GS3

G# 3

A3

A 3

AS3

A# 3

B3

B 3

C4

C 4

CS4

C# 4

D4

D 4

DS4

D# 4

E4

E 4

F4

F 4

FS4

F# 4

G4

G 4

GS4

G# 4

A4

A 4

AS4

A# 4

B4

B 4

C5

C 5

CS5

C# 5

D5

D 5

DS5

D# 5

E5

E 5

F5

F 5

FS5

F# 5

G5

G 5

GS5

G# 5

A5

A 5

AS5

A# 5

B5

B 5

C6

C 6

CS6

C# 6

D6

D 6

DS6

D# 6

E6

E 6

F6

F 6

FS6

F# 6

G6

G 6

GS6

G# 6

A6

A 6

AS6

A# 6

B6

B 6

C7

C 7

CS7

C# 7

D7

D 7

DS7

D# 7

E7

E 7

F7

F 7

FS7

F# 7

G7

G 7

GS7

G# 7

A7

A 7

AS7

A# 7

B7

B 7

C8

C 8

CS8

C# 8

D8

D 8

DS8

D# 8

E8

E 8

F8

F 8

FS8

F# 8

G8

G 8

GS8

G# 8

A8

A 8

AS8

A# 8

B8

B 8

C9

C 9

CS9

C# 9

D9

D 9

DS9

D# 9

E9

E 9

F9

F 9

FS9

F# 9

G9

G 9

GS9

G# 9

A9

A 9

AS9

A# 9

B9

B 9

C10

C 10

CS10

C# 10

D10

D 10

DS10

D# 10

E10

E 10

F10

F 10

FS10

F# 10

G10

G 10

NoSound

No sound.

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<'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 Eq for Note

impl From<Note> for u8

fn from(note: Note) -> Self

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

impl StructuralPartialEq for Note

impl TryFrom<u8> for Note

type Error = Error

The type returned in the event of a conversion error.

fn try_from(note: u8) -> Result<Self>

Performs the conversion.