Struct redact_composer_midi::gm::Instruments

pub struct Instruments {
    pub instruments: Vec<Instrument>,
}

A thin wrapper around a Vec<Instrument> with Add/Subtract operations.

Fields

instruments: Vec<Instrument>

A list of instruments.

Implementations

impl Instruments

pub fn all() -> Instruments

All instruments.

pub fn piano() -> Instruments

GM1 piano instruments.

pub fn tonal_percussive() -> Instruments

GM1 tonal percussive instruments.

pub fn organ() -> Instruments

GM1 organ instruments.

pub fn guitar() -> Instruments

GM1 guitar instruments.

pub fn bass() -> Instruments

GM1 bass instruments.

pub fn strings() -> Instruments

GM1 string instruments.

pub fn ensemble() -> Instruments

GM1 ensemble instruments.

pub fn brass() -> Instruments

GM1 brass instruments.

pub fn reed() -> Instruments

GM1 reed instruments.

pub fn pipe() -> Instruments

GM1 pipe instruments.

pub fn synth_lead() -> Instruments

GM1 synth lead instruments.

pub fn synth_pad() -> Instruments

GM1 synth pad instruments.

pub fn synth_fx() -> Instruments

GM1 synth FX instruments.

pub fn ethnic() -> Instruments

GM1 ethnic instruments.

pub fn percussive() -> Instruments

GM1 percussive instruments.

pub fn sound_fx() -> Instruments

GM1 sound FX instruments.

pub fn melodic() -> Instruments

Returns “melodic” instruments which have a clear tone, and are not overly percussive.

Trait Implementations

impl Add<Instrument> for Instruments

##Example

let pianos = Instruments { instruments: vec![Instrument::AcousticGrandPiano] }
                        + Instrument::BrightAcousticPiano;
assert_eq!(pianos, Instruments { instruments: vec![Instrument::AcousticGrandPiano, Instrument::BrightAcousticPiano] });

type Output = Instruments

The resulting type after applying the + operator.

fn add(self, rhs: Instrument) -> Self::Output

Performs the + operation.

impl Add<Instruments> for Instrument

##Example

let pianos = Instrument::AcousticGrandPiano
                + Instruments { instruments: vec![Instrument::BrightAcousticPiano] };
assert_eq!(pianos, Instruments { instruments: vec![Instrument::AcousticGrandPiano, Instrument::BrightAcousticPiano] });

type Output = Instruments

The resulting type after applying the + operator.

fn add(self, rhs: Instruments) -> Self::Output

Performs the + operation.

impl Add for Instruments

##Example

let pianos = Instruments { instruments: vec![Instrument::AcousticGrandPiano] }
                        + Instruments { instruments: vec![Instrument::BrightAcousticPiano] };
assert_eq!(pianos, Instruments { instruments: vec![Instrument::AcousticGrandPiano, Instrument::BrightAcousticPiano] });

type Output = Instruments

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for Instruments

fn clone(&self) -> Instruments

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Instruments

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

Formats the value using the given formatter.

impl From<Instruments> for Vec<Instrument>

##Example

let instruments = Instruments { instruments: vec![Instrument::AcousticGrandPiano, Instrument::BrightAcousticPiano] };
let vec_instruments: Vec<Instrument> = instruments.into();
assert_eq!(
    vec_instruments,
    vec![Instrument::AcousticGrandPiano, Instrument::BrightAcousticPiano]
);

fn from(value: Instruments) -> Self

Converts to this type from the input type.

impl IntoIterator for Instruments

type Item = Instrument

The type of the elements being iterated over.

type IntoIter = IntoIter<<Instruments as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Instruments

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<Instrument> for Instruments

##Example

let no_violins = Instruments { instruments: vec![Instrument::Violin, Instrument::Cello] }
                        - Instrument::Violin;
assert_eq!(no_violins, Instruments { instruments: vec![Instrument::Cello] });

let instruments = Instruments { instruments: vec![Instrument::AcousticGrandPiano, Instrument::BrightAcousticPiano] };

type Output = Instruments

The resulting type after applying the - operator.

fn sub(self, rhs: Instrument) -> Self::Output

Performs the - operation.

impl Sub for Instruments

##Example

let no_violins = Instruments { instruments: vec![Instrument::Violin, Instrument::Cello] }
                        - Instruments { instruments: vec![Instrument::Violin] };
assert_eq!(no_violins, Instruments { instruments: vec![Instrument::Cello] });

type Output = Instruments

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl StructuralPartialEq for Instruments