Struct KeySignature 

pub struct KeySignature { /* private fields */ }

A key signature represented by the number of sharps.

Flats are represented as negative sharps, so B-flat major has -2.

Implementations

impl KeySignature

pub fn new(sharps: IntegerType) -> Self

Creates a key signature from a sharp count.

pub fn from_altered_pitches(pitches: Vec<Pitch>) -> Self

Creates a non-traditional key signature from the pitches it alters, as music21 does when alteredPitches is assigned: E- and G# together, say, which no count of sharps can express. Such a signature has no sharp count and no key.

pub fn sharps(&self) -> Option<IntegerType>

Returns the number of sharps, with flats as negative values, or None for a non-traditional signature.

pub fn set_sharps(&mut self, sharps: IntegerType)

Replaces the sharp count, turning a non-traditional signature back into a traditional one.

pub fn set_altered_pitches(&mut self, pitches: Vec<Pitch>)

Replaces the altered pitches, turning the signature non-traditional.

pub fn is_non_traditional(&self) -> bool

Whether the signature is a list of altered pitches rather than a count of sharps or flats.

music21’s isNonTraditional. There sharps answers nought when this is true; Self::sharps answers None, which says both things at once.

pub fn set_non_traditional(&mut self, non_traditional: bool)

Makes the signature non-traditional, or traditional again: the setter of music21’s isNonTraditional.

Turning it on drops the sharp count and starts an empty list of altered pitches; turning it off restores a count of nought. Setting it to what it already is does nothing.

pub fn accidentals_apply_only_to_octave(&self) -> bool

Whether the altered pitches of a non-traditional signature carry octaves that limit where they apply, as F#4 altering only that octave. music21 records the flag; applying it is a stream’s job.

pub fn set_accidentals_apply_only_to_octave(&mut self, value: bool)

Sets whether the altered pitches apply only in their own octave.

pub fn description(&self) -> String

The description music21 prints after of: 3 sharps, 1 flat, no sharps or flats, or pitches: [E-, G#].

pub fn altered_pitches(&self) -> Result<Vec<Pitch>>

Returns the pitches this signature alters, in circle-of-fifths order and without octaves: F# C# G# for three sharps, B- E- A- for three flats; a non-traditional signature answers the pitches it was given.

pub fn accidental_by_step(&self, step: char) -> Result<Option<Accidental>>

Returns the accidental this signature puts on a step letter, if any.

pub fn transpose(&self, interval: &Interval) -> Result<Self>

Returns the signature of the major key this one’s major tonic moves to by the interval.

pub fn transpose_pitch_from_c(&self, pitch: &Pitch) -> Result<Pitch>

Transposes a pitch spelled in C into this key signature the way music21’s transposePitchFromC does: up a fifth per sharp, or up a fourth per flat, keeping the pitch’s own octave, so E4 in two sharps is F#4 and in three flats G4.

pub fn scale(&self, mode: &str) -> Result<Scale>

Returns the major or minor scale this signature implies.

pub fn as_key(&self, mode: &str) -> Key

Converts this signature to a key in the given mode.

pub fn try_as_key(&self, mode: Option<&str>, tonic: Option<&str>) -> Result<Key>

Converts this signature to a key, optionally inferring mode from tonic.

Trait Implementations

impl Clone for KeySignature

fn clone(&self) -> KeySignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeySignature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeySignature

Available on crate feature serde only.

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for KeySignature

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

KeySignature of 3 sharps, KeySignature of pitches: [E-, G#].

impl From<KeySignature> for StreamElement

fn from(value: KeySignature) -> Self

Converts to this type from the input type.

impl Serialize for KeySignature

Available on crate feature serde only.

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

where __S: Serializer,

Serialize this value into the given Serde serializer.