Struct MeterTerminal 

pub struct MeterTerminal { /* private fields */ }

One span of a bar: a ratio, and how strongly it is felt.

Implementations

impl MeterTerminal

pub fn new( numerator: UnsignedIntegerType, denominator: UnsignedIntegerType, ) -> Result<Self>

A span of numerator/denominator, undivided, weighing one.

pub fn from_ratio_string(ratio: &str) -> Result<Self>

The same, read from "3/8".

pub fn numerator(&self) -> UnsignedIntegerType

The numerator this span is written with.

pub fn denominator(&self) -> UnsignedIntegerType

The denominator this span is written with.

pub fn quarter_length(&self) -> FloatType

How long this span is in quarter notes.

pub fn weight(&self) -> FloatType

How strongly this span is felt: music21’s weight.

pub fn set_weight(&mut self, weight: FloatType)

Sets how strongly this span is felt.

pub fn parts(&self) -> &[MeterTerminal]

What this span is divided into. Empty where it is a leaf.

pub fn parts_mut(&mut self) -> &mut Vec<MeterTerminal>

The same, to be changed.

pub fn len(&self) -> usize

How many parts this span has at its top level, music21’s len.

pub fn is_empty(&self) -> bool

Whether this span is divided at all.

pub fn depth(&self) -> usize

How many levels of division this span has: music21’s depth. A leaf is nought.

pub fn flattened(&self) -> Vec<MeterTerminal>

Every leaf of this span, in order: music21’s flatten.

pub fn partition_by_parts(&mut self, parts: &[&str]) -> Result<()>

Divides this span into the parts named, as ["2/8", "3/8"].

The parts must come to what this span already is; a partition that lengthened or shortened the bar would not be one.

pub fn partition_by_count( &mut self, count: usize, load_default: bool, ) -> Result<()>

Divides this span into count parts, the way music21 divides it.

The first of Self::division_options with that many parts wins. A count nothing divides into leaves the first option standing, which is music21’s loadDefault.

pub fn partition_by_list( &mut self, numerators: &[UnsignedIntegerType], ) -> Result<()>

Divides this span by a list of numerators, as [3, 1] for {3/4+1/4}.

music21 reads the list against this span’s own denominator where the numerators come to its numerator, and against a finer one where they come to a multiple of it — [1, 1, 1, 1] of a 2/4 bar is four eighths, not four quarters.

pub fn subdivide(&mut self, count: usize) -> Result<()>

Divides this span into count parts and leaves those parts divided as they were: music21’s MeterTerminal.subdivide.

pub fn subdivide_partitions_equal( &mut self, divisions: Option<usize>, ) -> Result<()>

Divides every part of this span again, the way music21 divides it when nobody has said how: music21’s subdividePartitionsEqual.

divisions says how many parts each part becomes; None asks for the division each part conventionally takes — two for a part written in a binary numerator, three for one written in three, and threes for the compound numerators. A part nothing divides into is an error, which is what music21 raises and what a meter written in notes shorter than a 128th is forgiven.

pub fn division_options(&self) -> Vec<Vec<String>>

The ways music21 conventionally divides this meter, in the order it prefers them: music21’s getPartitionOptions.

pub fn level_list(&self, level: usize, flat: bool) -> Vec<MeterTerminal>

The terminals at one level of this sequence: music21’s getLevelList.

A part that is not divided is taken as it stands. A part that is gets recursed into while there are levels left to descend, and at the level asked for is either kept whole or, when flat, flattened into a single terminal carrying that part’s own weight.

pub fn level(&self, level: usize, flat: bool) -> Result<Self>

One level of this sequence as a sequence of its own: music21’s getLevel.

pub fn level_span(&self, level: usize) -> Vec<(FloatType, FloatType)>

Where each terminal of a level starts and ends, in quarter lengths from the start of this span: music21’s getLevelSpan.

pub fn offset_to_depth( &self, offset: FloatType, align: OffsetAlign, ) -> Result<usize>

How many levels of this sequence start at an offset: music21’s offsetToDepth.

A level counts when one of its parts begins where the offset does. Under OffsetAlign::Quantize the offset is first moved back to the start of the finest part holding it, so an offset inside a part still counts the levels that part begins.

pub fn set_weights_at_level( &mut self, level: usize, weights: &[FloatType], ) -> Result<()>

Weighs the terminals of a level, looping the weights given over them: the write half of music21’s setAccentWeight.

A level with no terminals, or no weights to give it, is an error rather than a silent nothing.

pub fn is_uniform_partition(&self, depth: usize) -> bool

Whether every part of a level is the same ratio: music21’s isUniformPartition.

pub fn partition_display(&self) -> String

The parts written out without the braces around them: music21’s partitionDisplay, so a bar of 2/4+6/8 reads as it was written.

pub fn subdivide_by_count(&self, count: usize) -> Result<Self>

This span divided into count parts, as a new sequence: music21’s subdivideByCount. The weight of this span goes with it.

pub fn subdivide_by_list( &self, numerators: &[UnsignedIntegerType], ) -> Result<Self>

This span divided by a list of numerators, as a new sequence: music21’s subdivideByList.

pub fn offset_to_index(&self, offset: FloatType) -> Result<usize>

Which part an offset in quarter notes falls in: music21’s offsetToIndex. An offset outside the span is an error.

pub fn offset_to_span( &self, offset: FloatType, permit_meter_modulus: bool, ) -> Result<(FloatType, FloatType)>

Where the part an offset falls in begins and ends: music21’s offsetToSpan. With permit_meter_modulus an offset past the end of the span is read within it.

pub fn offset_to_weight(&self, offset: FloatType) -> Result<FloatType>

The weight of the part an offset falls in: music21’s offsetToWeight.

pub fn partition_string(&self) -> String

How this span is written: 3/4 undivided, {1/4+1/4+1/4} divided.

Trait Implementations

impl Clone for MeterTerminal

fn clone(&self) -> MeterTerminal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MeterTerminal

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MeterTerminal

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 MeterTerminal

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

Formats the value using the given formatter.

impl PartialEq for MeterTerminal

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for MeterTerminal

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 StructuralPartialEq for MeterTerminal