1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

ix!();

use crate::{
    ControllerModulationSource,
    ModSourceArray,
};

//#[enum_dispatch(ModulationSourceControl)]
#[derive(Debug)]
pub enum ModulationSource {
    Lfo(Lfo),
    AdsrEnvelope(AdsrEnvelope),
    ControllerModulationSource(ControllerModulationSource),
}

pub type MaybeBoxedModulationSource 
= Option<Box<ModulationSource>>;

pub type ModulationSourceArray 
= ModSourceArray::<MaybeBoxedModulationSource>;

impl ModulationSourceControl for ModulationSource {

    fn get_type(&self) -> ModSrcType {
        match self {
            ModulationSource::Lfo(inner)                        => inner.get_type(),
            ModulationSource::AdsrEnvelope(inner)               => inner.get_type(),
            ModulationSource::ControllerModulationSource(inner) => inner.get_type(),
        }
    }
    fn get_output(&self) -> f64 {
        match self {
            ModulationSource::Lfo(inner)                        => inner.get_output(),
            ModulationSource::AdsrEnvelope(inner)               => inner.get_output(),
            ModulationSource::ControllerModulationSource(inner) => inner.get_output(),
        }
    }
    fn set_output(&mut self, x: f64) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.set_output(x),
            ModulationSource::AdsrEnvelope(inner)               => inner.set_output(x),
            ModulationSource::ControllerModulationSource(inner) => inner.set_output(x),
        }
    }
    fn get_output01(&self) -> f64 {
        match self {
            ModulationSource::Lfo(inner)                        => inner.get_output01(),
            ModulationSource::AdsrEnvelope(inner)               => inner.get_output01(),
            ModulationSource::ControllerModulationSource(inner) => inner.get_output01(),
        }
    }
    fn per_voice(&self) -> bool {
        match self {
            ModulationSource::Lfo(inner)                        => inner.per_voice(),
            ModulationSource::AdsrEnvelope(inner)               => inner.per_voice(),
            ModulationSource::ControllerModulationSource(inner) => inner.per_voice(),
        }
    }
    fn is_bipolar(&self) -> bool {
        match self {
            ModulationSource::Lfo(inner)                        => inner.is_bipolar(),
            ModulationSource::AdsrEnvelope(inner)               => inner.is_bipolar(),
            ModulationSource::ControllerModulationSource(inner) => inner.is_bipolar(),
        }
    }
    fn set_bipolar(&mut self, b: bool) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.set_bipolar(b),
            ModulationSource::AdsrEnvelope(inner)               => inner.set_bipolar(b),
            ModulationSource::ControllerModulationSource(inner) => inner.set_bipolar(b),
        }
    }
    fn process_block(&mut self) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.process_block(),
            ModulationSource::AdsrEnvelope(inner)               => inner.process_block(),
            ModulationSource::ControllerModulationSource(inner) => inner.process_block(),
        }
    }
    fn attack(&mut self) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.attack(),
            ModulationSource::AdsrEnvelope(inner)               => inner.attack(),
            ModulationSource::ControllerModulationSource(inner) => inner.attack(),
        }
    }
    fn release(&mut self) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.release(),
            ModulationSource::AdsrEnvelope(inner)               => inner.release(),
            ModulationSource::ControllerModulationSource(inner) => inner.release(),
        }
    }
    fn enabled(&self) -> bool {
        match self {
            ModulationSource::Lfo(inner)                        => inner.enabled(),
            ModulationSource::AdsrEnvelope(inner)               => inner.enabled(),
            ModulationSource::ControllerModulationSource(inner) => inner.enabled(),
        }
    }
    fn enable(&mut self, v: bool) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.enable(v),
            ModulationSource::AdsrEnvelope(inner)               => inner.enable(v),
            ModulationSource::ControllerModulationSource(inner) => inner.enable(v),
        }
    }
    fn reset(&mut self) {
        match self {
            ModulationSource::Lfo(inner)                        => inner.reset(),
            ModulationSource::AdsrEnvelope(inner)               => inner.reset(),
            ModulationSource::ControllerModulationSource(inner) => inner.reset(),
        }
    }
}