Enum Key 

pub enum Key {
    Major(u32),
    Minor(u32),
}

Musical key

Variants

Major(u32)

Major key (0 = C, 1 = C#, …, 11 = B)

Minor(u32)

Minor key (0 = C, 1 = C#, …, 11 = B)

Implementations

impl Key

pub fn name(&self) -> String

Get key name in musical notation (e.g., “C”, “Am”, “F#”, “D#m”)

Returns standard musical notation:

• Major keys: note name only (e.g., “C”, “C#”, “D”, “F#”)
• Minor keys: note name + “m” (e.g., “Am”, “C#m”, “Dm”, “F#m”)

Example

use stratum_dsp::analysis::result::Key;

assert_eq!(Key::Major(0).name(), "C");
assert_eq!(Key::Major(6).name(), "F#");
assert_eq!(Key::Minor(9).name(), "Am");
assert_eq!(Key::Minor(1).name(), "C#m");

pub fn numerical(&self) -> String

Get key in DJ standard numerical notation (e.g., “1A”, “2B”, “12A”)

Uses the circle of fifths mapping popularized in DJ software:

• Major keys: 1A-12A (1A = C, 2A = G, 3A = D, …, 12A = F)
• Minor keys: 1B-12B (1B = Am, 2B = Em, 3B = Bm, …, 12B = Dm)

The numbering follows the circle of fifths (up a fifth each step). Keys are displayed in standard musical notation by default (e.g., “C”, “Am”, “F#”).

Example

use stratum_dsp::analysis::result::Key;

assert_eq!(Key::Major(0).numerical(), "1A");   // C
assert_eq!(Key::Major(7).numerical(), "2A");   // G
assert_eq!(Key::Minor(9).numerical(), "1B");   // Am
assert_eq!(Key::Minor(4).numerical(), "2B");   // Em

pub fn from_numerical(notation: &str) -> Option<Self>

Get key from DJ standard numerical notation

Converts numerical notation (e.g., “1A”, “2B”, “12A”) back to a Key.

Arguments

• notation - Numerical key notation (e.g., “1A”, “2B”, “12A”)

Returns

Some(Key) if valid, None if invalid format

Example

use stratum_dsp::analysis::result::Key;

assert_eq!(Key::from_numerical("1A"), Some(Key::Major(0)));   // C
assert_eq!(Key::from_numerical("2A"), Some(Key::Major(7)));   // G
assert_eq!(Key::from_numerical("1B"), Some(Key::Minor(9)));   // Am
assert_eq!(Key::from_numerical("2B"), Some(Key::Minor(4)));   // Em
assert_eq!(Key::from_numerical("0A"), None);  // Invalid
assert_eq!(Key::from_numerical("13A"), None); // Invalid

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate 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<'de> Deserialize<'de> for Key

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Key

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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 Serialize for Key

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 Key

impl Eq for Key

impl StructuralPartialEq for Key