Struct Duration 

pub struct Duration { /* private fields */ }

Rhythmic duration measured in quarter lengths.

A quarter note has a quarter length of 1.0; an eighth note is 0.5; a whole note is 4.0.

Implementations

impl Duration

pub fn new(quarter_length: FloatType) -> Result<Self>

Creates a duration from a quarter-length value.

pub fn quarter() -> Self

Returns a quarter-note duration.

pub fn half() -> Self

Returns a half-note duration.

pub fn whole() -> Self

Returns a whole-note duration.

pub fn eighth() -> Self

Returns an eighth-note duration.

pub fn from_type(duration_type: DurationType) -> Self

Creates a duration from a note-value type.

pub fn from_type_with_dots(duration_type: DurationType, dots: u32) -> Self

Creates a duration from a note-value type carrying augmentation dots.

pub fn type_and_dots(&self) -> Option<(DurationType, u32)>

Returns the note-value type and dot count that together make exactly this length, such as a half note with one dot for 3.0. None for a length no single dotted note value has, such as a tuplet or a tie.

pub fn dots(&self) -> u32

Returns the augmentation dots on this duration, or 0 when it is not a single dotted note value.

pub fn ordinal(&self) -> Option<usize>

music21’s ordinal for the duration’s type, or None where music21 says complex or the duration is zero: a duration whose quarter length is not a single dotted note value.

pub fn augment_or_diminish(&self, factor: FloatType) -> Result<Duration>

Returns the duration scaled by a positive factor: music21’s augmentOrDiminish, so a quarter by two is a half.

pub fn tuplet(&self) -> Option<Tuplet>

The tuplet this length is written as, if any: the first of quarter_length_to_tuplet.

A length that is already a plain written value is that value rather than a tuplet of some other one, so a quarter answers None: music21 tries the exact match before it tries any ratio, and a plain quarter is a quarter even though it is also two thirds of a dotted quarter in a triplet.

pub fn tuplets(&self) -> Vec<Tuplet>

The tuplets this length is written inside: the ones a caller set, or the one read off the length when nobody has.

This is music21’s tuplets, which is likewise inferred until it is assigned. Setting it to nothing is not the same as never setting it: two thirds of a quarter reads as a quarter triplet on its own, and stays two thirds of a quarter written as no tuplet once told so.

pub fn aggregate_tuplet_multiplier(&self) -> FractionType

What the written values are multiplied by to give the sounding length: music21’s aggregateTupletMultiplier, every tuplet’s ratio multiplied together, so a triplet inside a quintuplet is 8/15.

pub fn quarter_length_no_tuplets(&self) -> FloatType

The total of the written values, before any tuplet shortens them: music21’s quarterLengthNoTuplets.

pub fn set_tuplets(&mut self, tuplets: Vec<Tuplet>)

Says what tuplets this length is written inside, keeping the written values and changing the sounding length to match: music21’s tuplets setter.

pub fn append_tuplet(&mut self, tuplet: Tuplet)

Writes this length inside one more tuplet, shortening it by that tuplet’s ratio: music21’s appendTuplet.

pub fn components(&self) -> Vec<(DurationType, u32)>

The written note values this length is made of, tied together: music21’s components.

This is the first half of quarter_conversion, read over the written length. A length whose tuplets a caller has set is read as the tie those tuplets leave, without looking for a tuplet of its own.

pub fn is_complex(&self) -> bool

Whether the length needs more than one written value, tied: music21’s isComplex.

pub fn dot_groups(&self) -> Vec<u32>

The dots on the written value, as the one dot group the crate keeps: music21’s dotGroups, which can also write one length twice over where a mensural notation asks for it.

pub fn clear(&mut self)

Takes the length away: music21’s clear, which empties the written values so the duration sounds for no time. The tuplets it was told stay.

pub fn add_duration_tuple(&mut self, duration_type: DurationType, dots: u32)

Ties one more written value onto the end: music21’s addDurationTuple, which lengthens the duration by that value inside whatever tuplets it is written in.

pub fn component_index_at_qtr_position( &self, position: FloatType, ) -> Result<usize>

Which written value is sounding at a position within the duration: music21’s componentIndexAtQtrPosition. The positions are counted in the written values, before any tuplet scales them, and the start and the very end answer the first and the last value.

pub fn component_start_time(&self, index: usize) -> Result<FloatType>

Where a written value starts within the duration, counted in the written values: music21’s componentStartTime. An index past the values is an error.

pub fn full_name(&self) -> String

Returns music21’s fullName for a single written note value, such as "Dotted Quarter", "Double Dotted Half", "Imperfect Longa" or "Quarter Triplet (2/3 QL)".

A length that has to be written as a tie names each of its values and joins them, "Quarter tied to 16th (1 1/4 total QL)". A length no note value reaches is "Inexpressible" and a zero one is "Zero Duration (0 total QL)", both as music21 names them.

pub fn duration_type(&self) -> Option<DurationType>

Returns the note-value type whose undotted length this duration is.

Returns None for a length that is not a plain note value, such as a dotted or tuplet duration.

pub fn quarter_length(&self) -> FloatType

Returns the duration in quarter lengths.

pub fn set_quarter_length(&mut self, quarter_length: FloatType) -> Result<()>

Updates the duration in quarter lengths.

Trait Implementations

impl Clone for Duration

fn clone(&self) -> Duration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Duration

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

Formats the value using the given formatter.

impl Default for Duration

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Duration

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 From<Duration> for Rest

fn from(value: Duration) -> Self

Converts to this type from the input type.

impl PartialEq for Duration

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Duration

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<f64> for Duration

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<i32> for Duration

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.