Struct Part 

pub struct Part { /* private fields */ }

Describes a score’s part. A Part is played by a single instrument and can contain multiple phrases, played sequentially or simultaneously

Implementations

impl Part

pub fn new(instrument: Instrument) -> Part

Returns a new empty Part with the given name and instrument

Arguments

• name - title of the Part
• instrument - instrument playing the Part

Examples found in repository

examples/praeludium_no1_single_phrase.rs (line 17)

fn praeludium() -> Result<Score> {
    let mut part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(phrase()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_multi_phrase.rs (line 27)

fn praeludium() -> Result<Score> {
    let mut part: Part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(right_hand()?, 0.);
    part.add_phrase(left_hand_high_note()?, 0.);
    part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_organ_piano.rs (line 23)

fn praeludium() -> Result<Score> {
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    let mut organ_part = Part::new(Instrument::ChurchOrgan);

    piano_part.add_phrase(right_hand()?, 0.);
    organ_part.add_phrase(left_hand_high_note()?, 0.);
    organ_part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(piano_part);
    score.add_part(organ_part);
    Ok(score)
}

examples/scales_example.rs (line 22)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a simple C Minor Scale on octave 4 (this requires the `composition` feature)
    let s = Scale::new(
        compute_pitch(NoteName::Do, Accidental::Natural, 4)?,
        ScaleMode::Aeolian,
    );

    // Create a phrase that just plays the scale as a sequence of quavers (half beat)
    let phrase = Phrase::from_notes_sequence(Note::new_sequence(QUAVER, MF, s.n_pitches(15)))?;

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase, 0.);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("scale_example.mid")?)?;
    Ok(())
}

examples/readme_example.rs (line 31)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
    // with crotchets, at MezzoForte volume
    let mut phrase_to_repeat = Phrase::new();
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);

    // Create a Strings part that plays the phrase from beat 0.5
    // (at the same time as the piano but shifted half a beat)
    let mut violins_part = Part::new(Instrument::StringEnsemble1);
    violins_part.add_phrase(phrase_to_repeat, 0.5);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);
    score.add_part(violins_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("readme_example.mid")?)?;
    Ok(())
}

pub fn set_name<S: ToString>(&mut self, name: S)

Sets a name for the Part. The name does not have to be unique.

pub fn add_phrase(&mut self, phrase: Phrase, start_beat: f64)

Inserts a Phrase in the Part. The phrase will start at beat start_beat. Each beat corresponds to 1.0 in rhythm value. The Phrase can be played in parallel with other phrases if start_beat is smaller then their length.

Examples found in repository

examples/praeludium_no1_single_phrase.rs (line 19)

fn praeludium() -> Result<Score> {
    let mut part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(phrase()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_multi_phrase.rs (line 29)

fn praeludium() -> Result<Score> {
    let mut part: Part = Part::new(Instrument::AcousticGrandPiano);

    part.add_phrase(right_hand()?, 0.);
    part.add_phrase(left_hand_high_note()?, 0.);
    part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(part);
    Ok(score)
}

examples/praeludium_no1_organ_piano.rs (line 26)

fn praeludium() -> Result<Score> {
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    let mut organ_part = Part::new(Instrument::ChurchOrgan);

    piano_part.add_phrase(right_hand()?, 0.);
    organ_part.add_phrase(left_hand_high_note()?, 0.);
    organ_part.add_phrase(left_hand_low_note()?, 0.);

    let mut score = Score::new(
        "Praeludium No 1 in C Major",
        Tempo::new(96)?,
        Some(Metadata {
            key_signature: NN::C as i8,
            mode: Mode::Major,
            time_numerator: 4,
            time_denominator: 4,
        }),
    );
    score.add_part(piano_part);
    score.add_part(organ_part);
    Ok(score)
}

examples/scales_example.rs (line 23)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a simple C Minor Scale on octave 4 (this requires the `composition` feature)
    let s = Scale::new(
        compute_pitch(NoteName::Do, Accidental::Natural, 4)?,
        ScaleMode::Aeolian,
    );

    // Create a phrase that just plays the scale as a sequence of quavers (half beat)
    let phrase = Phrase::from_notes_sequence(Note::new_sequence(QUAVER, MF, s.n_pitches(15)))?;

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase, 0.);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("scale_example.mid")?)?;
    Ok(())
}

examples/readme_example.rs (line 32)

fn main() -> Result<(), Box<dyn Error>> {
    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
    // with crotchets, at MezzoForte volume
    let mut phrase_to_repeat = Phrase::new();
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);
    phrase_to_repeat.add_note(Note::new(
        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
        CROTCHET,
        MF,
    )?);

    // Create a piano part that plays the phrase from beat 0
    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);

    // Create a Strings part that plays the phrase from beat 0.5
    // (at the same time as the piano but shifted half a beat)
    let mut violins_part = Part::new(Instrument::StringEnsemble1);
    violins_part.add_phrase(phrase_to_repeat, 0.5);

    // Create a score with a tempo of 60 (one beat per second) and add both parts
    let mut score = Score::new("my score", Tempo::new(60)?, None);
    score.add_part(piano_part);
    score.add_part(violins_part);

    // Write the score to a MIDI file for playback
    score.write_midi_file(File::create("readme_example.mid")?)?;
    Ok(())
}

pub fn append_phrase_to_previous(&mut self, phrase: Phrase)

Appends a Phrase immediately at the end of the last added Phrase. If phrases added before the last one were longer, they can be played in parallel with the new Phrase.

pub fn append_phrase_to_part_end(&mut self, phrase: Phrase)

Appends a Phrase immediately at the end of the entire Part, i.e. the end of the Phrase that ends the latest

pub fn name(&self) -> &str

Returns the title of the Part

pub fn phrases(&self) -> &[(f64, Phrase)]

Returns the map of phrases of the Part

pub fn instrument(&self) -> Instrument

Returns the instrument playing the Part

pub fn duration(&self) -> f64

Trait Implementations

impl Clone for Part

fn clone(&self) -> Part

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Part

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

Formats the value using the given formatter.

impl Default for Part

fn default() -> Part

Returns the “default value” for a type.

impl PartialEq for Part

fn eq(&self, other: &Part) -> 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 StructuralPartialEq for Part