Struct Note 

pub struct Note { /* private fields */ }

A pitched note.

Implementations

impl Note

pub fn from_name(name: impl AsRef<str>) -> Result<Self>

Builds a note from a pitch name such as "C#4" or "E-".

pub fn from_number(number: FloatType) -> Result<Self>

Builds a note from a pitch-space number, where 60 is middle C.

pub fn from_pitch(pitch: Pitch) -> Self

Builds a note from an existing Pitch.

pub fn pitch(&self) -> &Pitch

Returns the note’s pitch.

pub fn set_pitch(&mut self, pitch: Pitch)

Sets the note’s pitch, keeping its duration and notation: music21’s Note.pitch setter.

pub fn pitch_name(&self) -> String

Returns the pitch name without an octave, such as "C#" or "E-".

pub fn pitch_name_with_octave(&self) -> String

Returns the pitch name with an octave when one is set.

pub fn step(&self) -> char

The pitch’s step letter.

pub fn octave(&self) -> Octave

The pitch’s octave, if it has one.

pub fn pitches(&self) -> Vec<Pitch>

The note’s one pitch as a list, the shape a chord’s pitches has.

pub fn full_name(&self) -> String

music21’s fullName: E-flat in octave 4 Quarter Note, with the duration’s name left out when the note has none.

pub fn duration(&self) -> Option<&Duration>

Returns the note duration when one has been assigned.

pub fn set_duration(&mut self, duration: Duration)

Assigns a duration to the note.

pub fn with_duration(self, duration: Duration) -> Self

Returns a copy of this note with the supplied duration.

pub fn grace_note(&self, appoggiatura: bool) -> Self

This note as a grace note: written as it is, sounding for no time, music21’s getGrace. A grace note is slashed and takes no time, and an appoggiatura is unslashed and takes its time from the note it leans on.

use music21_rs::{Duration, DurationType, Note};

let note = Note::from_name("G4")?.with_duration(Duration::half());
let grace = note.grace_note(false);
let duration = grace.duration().unwrap();
assert_eq!(duration.quarter_length(), 0.0);
assert_eq!(duration.components(), [(DurationType::Half, 0)]);
assert!(duration.grace().unwrap().slash());
assert!(!note.grace_note(true).duration().unwrap().grace().unwrap().slash());

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

Returns this note transposed by the interval, keeping everything but its pitch.

pub fn beams(&self) -> &Beams

The beams joining this note’s flags to its neighbours’: music21’s beams.

pub fn beams_mut(&mut self) -> &mut Beams

The same, to be changed.

pub fn set_beams(&mut self, beams: Beams)

Replaces the beams.

pub fn tie(&self) -> Option<&Tie>

The tie joining this note to its neighbours, if any.

pub fn set_tie(&mut self, tie: Option<Tie>)

Ties this note, or unties it with None.

pub fn notehead(&self) -> Notehead

The shape the note head is drawn with.

pub fn set_notehead(&mut self, notehead: Notehead)

Sets the shape the note head is drawn with.

pub fn notehead_fill(&self) -> Option<bool>

Whether the note head is filled in: Some(true) filled, Some(false) hollow, None to let the duration decide, which is music21’s default.

pub fn set_notehead_fill(&mut self, fill: Option<bool>)

Sets whether the note head is filled in.

pub fn notehead_parenthesis(&self) -> bool

Whether the note head is written in parentheses.

pub fn set_notehead_parenthesis(&mut self, parenthesis: bool)

Sets whether the note head is written in parentheses.

pub fn stem_direction(&self) -> StemDirection

Which way the stem points.

pub fn set_stem_direction(&mut self, direction: StemDirection)

Sets which way the stem points.

pub fn color(&self) -> Option<&str>

The colour the note is written in, if one was said: music21 keeps this on the note’s style.

pub fn set_color(&mut self, color: Option<String>)

Sets the colour the note is written in.

pub fn size(&self) -> Option<NoteSize>

How large the note is drawn, where a score says: music21 keeps this on the note’s style as noteSize.

pub fn set_size(&mut self, size: Option<NoteSize>)

Says how large the note is drawn.

pub fn volume(&self) -> Volume

How loud the note is. music21 makes a volume on first access, so this answers a default one for a note nobody has marked; see Self::has_volume_information to tell the two apart.

pub fn set_volume(&mut self, volume: Option<Volume>)

Sets how loud the note is, or clears it.

pub fn stored_instrument(&self) -> Option<&Instrument>

The instrument this one note is played on, over whichever is in force where it stands: music21’s storedInstrument.

pub fn set_stored_instrument(&mut self, instrument: Option<Instrument>)

Sets the instrument this one note is played on, or clears it.

pub fn instrument(&self) -> Option<&Instrument>

The instrument that plays this note, as far as the note itself can say: music21’s getInstrument, whose search of the streams around a note is a question for whoever holds the stream.

pub fn has_volume_information(&self) -> bool

Whether a volume was ever set on this note: music21’s hasVolumeInformation, which asks only whether the object is there and not whether a velocity was written on it, so a bare Volume::new() set on a note counts.

pub fn expressions(&self) -> &[Expression]

The fermatas, ornaments and other marks written on the note: music21’s expressions.

pub fn expressions_mut(&mut self) -> &mut Vec<Expression>

The same, to be changed.

pub fn hidden(&self) -> bool

Whether it is left off the printed page, keeping its place and its time: music21’s style.hideObjectOnPrint, which a score uses for a rest that only fills out a voice.

pub fn set_hidden(&mut self, hidden: bool)

Says whether it is left off the printed page.

pub fn id(&self) -> Option<&str>

The name the note is known by, where it has been given one: music21’s id, when that is a name and not a number of its own making.

pub fn set_id(&mut self, id: Option<String>)

Names the note, or takes its name away.

pub fn articulations(&self) -> &[Articulation]

How the note is played: its accents, staccatos, bowings and fingerings, music21’s articulations.

pub fn articulations_mut(&mut self) -> &mut Vec<Articulation>

The same, to be changed.

pub fn lyrics(&self) -> &[Lyric]

The syllables sung on this note, one per verse.

pub fn lyrics_mut(&mut self) -> &mut Vec<Lyric>

The syllables sung on this note, for editing in place.

pub fn lyric(&self) -> Option<String>

The text of the first verse, with the hyphens of every further verse joined by newlines: music21’s lyric.

pub fn set_lyric(&mut self, lyric: Option<&str>) -> Result<()>

Replaces every lyric with one verse of text, or clears them with None. Newlines start further verses, and hyphens say where each syllable falls in its word: music21’s lyric setter.

pub fn add_lyric( &mut self, text: &str, number: Option<IntegerType>, apply_raw: bool, ) -> Result<()>

Adds a syllable as a verse: music21’s addLyric.

With no number it becomes the next verse. With one, it replaces the text of the verse already carrying that number — leaving where that syllable falls in its word alone, as music21’s plain text assignment does — and only becomes a new verse when no verse has it. Hyphens in the text say where the syllable falls in its word unless apply_raw is set, which takes the text as written.

pub fn insert_lyric( &mut self, text: &str, index: usize, apply_raw: bool, ) -> Result<()>

Puts a syllable in front of the verse at index, moving the verses from there on down a line: music21’s insertLyric.

An index past the end appends, as inserting into a list does.

Trait Implementations

impl Clone for Note

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Note

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Note

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 Note

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

Formats the value using the given formatter.

impl From<&Pitch> for Note

fn from(value: &Pitch) -> Self

Converts to this type from the input type.

impl From<Note> for PercussionNote

fn from(value: Note) -> Self

Converts to this type from the input type.

impl From<Note> for StreamElement

fn from(value: Note) -> Self

Converts to this type from the input type.

impl From<Pitch> for Note

fn from(value: Pitch) -> Self

Converts to this type from the input type.

impl FromStr for Note

type Err = Error

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl IntoNote for Note

fn try_into_note(self) -> Result<Note>

Converts the value into a note.

const FROM_INTEGER_PITCH: bool = false

Whether this value came from an integer pitch class or MIDI-like number.

impl IntoNote for &Note

fn try_into_note(self) -> Result<Note>

Converts the value into a note.

const FROM_INTEGER_PITCH: bool = false

Whether this value came from an integer pitch class or MIDI-like number.

impl Serialize for Note

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.

impl TryFrom<&str> for Note

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self>

Performs the conversion.

impl TryFrom<String> for Note

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self>

Performs the conversion.

impl TryFrom<i32> for Note

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: IntegerType) -> Result<Self>

Performs the conversion.