Struct RampedStatesMap

pub struct RampedStatesMap { /* private fields */ }

A simple implementation of a BufferStates that allows for parameters to change between the start and end of a buffer.

Each parameter can be either constant or ramped between two values.

For numeric parameters, the ramp is linear, for other parameter types the value changes half-way through the buffer.

Implementations

impl RampedStatesMap

pub fn new<'a, S: AsRef<str> + 'a, H: BuildHasher, H_: BuildHasher>( infos: impl IntoIterator<Item = InfoRef<'a, S>> + 'a, start_overrides: &HashMap<&str, InternalValue, H>, end_overrides: &HashMap<&str, InternalValue, H_>, buffer_size: usize, ) -> Self

Constructor that creates a RampedStatesMap from a list of Infos and overrides.at the start and end of the buffer.

These overrides work the same way as in override_defaults.

Note that if you want to pass this into a synth, you should use Self::new_synth instead.

Examples

let infos = vec![
  StaticInfoRef {
    title: "Numeric",
    short_title: "Numeric",
    unique_id: "numeric",
    flags: Default::default(),
    type_specific: TypeSpecificInfoRef::Numeric {
      default: 0.0,
      valid_range: 0.0..=1.0,
      units: None,
    },
  },
];

let start_overrides: HashMap<_, _> = vec![].into_iter().collect();
let end_overrides: HashMap<_, _> = vec![("numeric", InternalValue::Numeric(0.5))].into_iter().collect();
let states = RampedStatesMap::new(infos.iter().cloned(), &start_overrides, &end_overrides, 10);

match states.get_numeric("numeric") {
  Some(NumericBufferState::PiecewiseLinear(_)) => (),
  _ => panic!("Expected a ramped value"),
};

Panics

Panics if start_overrides or end_overrides do not match the type of the parameter specified in infos.

Also panics if any of the enum parameters in infos has a number of values that will not fit into a u32.

pub fn new_synth<'a, 'b: 'a>( infos: impl IntoIterator<Item = InfoRef<'a, &'b str>> + 'a, start_overrides: &HashMap<&str, InternalValue>, end_overrides: &HashMap<&str, InternalValue>, buffer_size: usize, ) -> Self

Create a new RampedStatesMap for synths from a list of Infos and overrides.

This is similar to Self::new, but it also includes the controller parameters that are common to all synths. (crate::synth::CONTROLLER_PARAMETERS).

Thus, this is more appropriate to use if you plan to pass the parameters to a synth.

Examples

let infos = vec![
  StaticInfoRef {
    title: "Numeric",
    short_title: "Numeric",
    unique_id: "numeric",
    flags: Default::default(),
    type_specific: TypeSpecificInfoRef::Numeric {
      default: 0.0,
      valid_range: 0.0..=1.0,
      units: None,
    },
  },
];

let start_overrides = vec![(MOD_WHEEL_PARAMETER, InternalValue::Numeric(1.0))].into_iter().collect();
let end_overrides = vec![("numeric", InternalValue::Numeric(0.5))].into_iter().collect();
let states = RampedStatesMap::new_synth(
  infos.iter().cloned(),
  &start_overrides,
  &end_overrides,
  10
);

// If we only overrode a value at the beginning or end
// it should be ramped
match states.get_numeric("numeric") {
  Some(NumericBufferState::PiecewiseLinear(_)) => (),
  _ => panic!("Expected a ramped value"),
};
match states.get_numeric(MOD_WHEEL_PARAMETER) {
  Some(NumericBufferState::PiecewiseLinear(_)) => (),
  _ => panic!("Expected a ramped value"),
};

// Params left at default should be constants
match states.get_numeric(PITCH_BEND_PARAMETER) {
  Some(NumericBufferState::Constant(0.0)) => (),
  _ => panic!("Expected a constant value"),
};

Panics

Panics if start_overrides or end_overrides do not match the type of the parameter specified in infos.

pub fn new_const<'a, S: AsRef<str> + 'a>( infos: impl IntoIterator<Item = InfoRef<'a, S>> + 'a, overrides: &HashMap<&str, InternalValue>, ) -> Self

Helper to make a RampedStatesMap with all parameters constant.

This is useful for performance testing because while the parameters are constant at run-time, the RampedStatesMap has the ability to ramp between values, so consumers cannot be specialized to handle constant values only

Note that if you want to pass this into a synth, you should use Self::new_const_synth instead.

Examples

let infos = vec![
  StaticInfoRef {
    title: "Numeric",
    short_title: "Numeric",
    unique_id: "numeric",
    flags: Default::default(),
    type_specific: TypeSpecificInfoRef::Numeric {
      default: 0.0,
      valid_range: 0.0..=1.0,
      units: None,
    },
  },
];

let overrides = vec![("numeric", InternalValue::Numeric(0.5))].into_iter().collect();
let states = RampedStatesMap::new_const(infos.iter().cloned(), &overrides);
match states.get_numeric("numeric") {
  Some(NumericBufferState::Constant(0.5)) => (),
  _ => panic!("Expected constant value of 0.5"),
};

pub fn new_const_synth<'a, 'b: 'a>( infos: impl IntoIterator<Item = InfoRef<'a, &'b str>> + 'a, overrides: &HashMap<&str, InternalValue>, ) -> Self

Create a new RampedStatesMap for synths with all parameters constant.

This is useful for performance testing because while the parameters are constant at run-time, the RampedStatesMap has the ability to ramp between values, so consumers cannot be specialized to handle constant values only

This is similar to Self::new_const, but it also includes the controller parameters that are common to all synths. (crate::synth::CONTROLLER_PARAMETERS).

Thus, this is more appropriate to use if you plan to pass the parameters to a synth.

Examples

let infos = vec![
  StaticInfoRef {
    title: "Numeric",
    short_title: "Numeric",
    unique_id: "numeric",
    flags: Default::default(),
    type_specific: TypeSpecificInfoRef::Numeric {
      default: 0.0,
      valid_range: 0.0..=1.0,
      units: None,
    },
  },
];
let overrides = vec![("numeric", InternalValue::Numeric(0.5))].into_iter().collect();
let states = RampedStatesMap::new_const_synth(infos.iter().cloned(), &overrides);

// Overridden parameters get the values you passed in
match states.get_numeric("numeric") {
  Some(NumericBufferState::Constant(0.5)) => (),
  _ => panic!("Expected constant value of 0.5"),
};

// Controller parameters will also be included
match states.get_numeric(MOD_WHEEL_PARAMETER) {
  Some(NumericBufferState::Constant(0.0)) => (),
  _ => panic!("Expected constant value of 0.0"),
};

Trait Implementations

impl BufferStates for RampedStatesMap

fn get_by_hash( &self, id_hash: IdHash, ) -> Option<BufferState<impl Iterator<Item = PiecewiseLinearCurvePoint> + Clone, impl Iterator<Item = TimedValue<u32>> + Clone, impl Iterator<Item = TimedValue<bool>> + Clone>>

Get the state of a parameter by it’s hashed unique ID.

fn get( &self, unique_id: &str, ) -> Option<BufferState<impl Iterator<Item = PiecewiseLinearCurvePoint> + Clone, impl Iterator<Item = TimedValue<u32>> + Clone, impl Iterator<Item = TimedValue<bool>> + Clone>>

Get the state of a parameter by it’s unique ID.

fn numeric_by_hash( &self, param_id: IdHash, ) -> Option<NumericBufferState<impl Iterator<Item = PiecewiseLinearCurvePoint> + Clone>>

Get the state of a numeric parameter by it’s hashed unique ID.

fn get_numeric( &self, unique_id: &str, ) -> Option<NumericBufferState<impl Iterator<Item = PiecewiseLinearCurvePoint> + Clone>>

Get the state of a numeric parameter by it’s unique ID.

fn enum_by_hash( &self, param_id: IdHash, ) -> Option<EnumBufferState<impl Iterator<Item = TimedValue<u32>> + Clone>>

Get the state of an enum parameter by it’s hashed unique ID.

fn get_enum( &self, unique_id: &str, ) -> Option<EnumBufferState<impl Iterator<Item = TimedValue<u32>> + Clone>>

Get the state of an enum parameter by it’s unique ID.

fn switch_by_hash( &self, param_id: IdHash, ) -> Option<SwitchBufferState<impl Iterator<Item = TimedValue<bool>> + Clone>>

Get the state of a switch parameter by it’s hashed unique ID.

fn get_switch( &self, unique_id: &str, ) -> Option<SwitchBufferState<impl Iterator<Item = TimedValue<bool>> + Clone>>

Get the state of a switch parameter by it’s unique ID.

impl Clone for RampedStatesMap

fn clone(&self) -> RampedStatesMap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RampedStatesMap

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

Formats the value using the given formatter.

impl Default for RampedStatesMap

fn default() -> RampedStatesMap

Returns the “default value” for a type.