Enum Key

pub enum Key {
    CMajor,
    DFlatMajor,
    DMajor,
    EFlatMajor,
    EMajor,
    FMajor,
    FSharpMajor,
    GMajor,
    AFlatMajor,
    AMajor,
    BFlatMajor,
    BMajor,
    CMinor,
    CSharpMinor,
    DMinor,
    EFlatMinor,
    EMinor,
    FMinor,
    FSharpMinor,
    GMinor,
    GSharpMinor,
    AMinor,
    BFlatMinor,
    BMinor,
}

Variants

CMajor

DFlatMajor

DMajor

EFlatMajor

EMajor

FMajor

FSharpMajor

GMajor

AFlatMajor

AMajor

BFlatMajor

BMajor

CMinor

CSharpMinor

DMinor

EFlatMinor

EMinor

FMinor

FSharpMinor

GMinor

GSharpMinor

AMinor

BFlatMinor

BMinor

Implementations

impl Key

pub fn from_string(s: &str) -> Result<Self, ()>

Tries parsing the Key from a string. Just a wrapper around KeyParser::try_from_string().

pub fn from_numeric(number: i32, is_major: bool) -> Result<Self, ()>

Get the key from a numeric representation. Mainly used internally. Number needs to be from 1-12 (1=C,2=D,3=E…) and is_major defining if you want the major or minor version of the note. Returns an error if number is <1 or >12.

pub fn from_numeric_wrapping(number: i32, is_major: bool) -> Self

Same as Key::from_numeric() but number is getting wrapped. So 0 would be wrapped to 12, -1 to 11, 13 to 1…

pub fn numeric(&self) -> (i32, bool)

Returns the numeric representation of this Key variant.

pub fn is_major(&self) -> bool

Returns true if this key is a major key, false if it is minor.

pub fn from_open_key_numeric(number: i32, is_major: bool) -> Result<Self, ()>

pub fn from_open_key_numeric_wrapping( number: i32, is_major: bool, ) -> Result<Self, ()>

pub fn open_key_numeric(&self) -> (i32, bool)

pub fn from_lancelot_numeric(number: i32, is_major: bool) -> Result<Self, ()>

pub fn from_lancelot_numeric_wrapping( number: i32, is_major: bool, ) -> Result<Self, ()>

pub fn lancelot_numeric(&self) -> (i32, bool)

pub fn traditional(&self) -> String

Returns the traditional string representation. Eg Abm, F#m, F…

pub fn open_key(&self) -> String

Returns the open key string representation. Eg 1m, 1d, 2m… 12m,12d

pub fn lancelot(&self) -> String

Returns the lancelot string representation. Eg 1A, 1B, 2A… 12A, 12B

impl Key

pub fn transpose_semitones(&self, semitones: i32) -> Self

Transpose this key by n semitones

pub fn transpose_tones(&self, tones: i32) -> Self

Transpose this key by n full tones

pub fn transpose_factor(&self, factor: f32) -> Self

Transpose this key by a factor. 0.5 would be half the tempo, 2.0 twice the tempo. (Imagine a pitch fader on a vinyl recorder)

pub fn transpose_bpm(&self, initial_bpm: f32, bpm: f32) -> Self

Transpose this key by an initial bpm and a target bpm. Imagine a track has the Key 3A at 135.0bpm (initial_bpm) and you want to know what bpm it is at 140.4bpm (target bpm).

pub fn to_lancelot_i32(&self) -> i32

Return the i32 representation of this Key in the lancelot sorting. The i32 will be between 0 and 23. This is helpful for serialization and sorting.

pub fn try_from_lancelot_i32(number: i32) -> Result<Self, ()>

Try turning an i32 in lancelot sorting into a Key object. See Key::to_lancelot_i32.

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl Display for Key

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

Formats the value using the given formatter.

impl PartialEq for Key

fn eq(&self, other: &Key) -> 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 Copy for Key

impl StructuralPartialEq for Key