Struct SwitchBlock 

pub struct SwitchBlock<T: Apply>
where
    T::Output: DefaultStorage,
    BlockData: FromPass<T::Output>,
{
    pub data: BlockData,
    /* private fields */
}

Switches between multiple input signals based on a condition.

The condition is the first input, and the rest are the signals to switch between. The block will output the signal that corresponds to the index of the `cases`` parameter that matches the condition input. If no matches are found, it will output the last input. For example:

use core::time::Duration;
use pictorus_blocks::SwitchBlock;
use pictorus_traits::ProcessBlock;
use pictorus_block_data::BlockData as OldBlockData;
use pictorus_traits::Context;

#[derive(Default)]
struct StubContext {}

impl Context for StubContext {
    fn time(&self) -> Duration {
        Duration::from_secs(0)
    }

    fn timestep(&self) -> Option<Duration> {
        None
    }

    fn fundamental_timestep(&self) -> Duration {
        Duration::from_millis(100)
    }
}

let ctxt = StubContext::default();
let mut block = SwitchBlock::<(f64, f64, f64)>::default();
// If condition is 0, output the signal at index 0
// If condition is 1, output the signal at index 1
// If condition is anything else, output the signal at index 1
let cases = OldBlockData::from_vector(&[0.0, 1.0]);
let parameters = <SwitchBlock<(f64, f64, f64)> as ProcessBlock>::Parameters::new(&cases);
// Here we have a condition of 0.0, and inputs of [1.0, 2.0]
// Since condition matches case 0, the output will be 1.0
let input = (0.0, 1.0, 2.0);
let output = block.process(&parameters, &ctxt, input);
assert_eq!(output, 1.0);

Fields

data: BlockData

Trait Implementations

impl<T: Apply> Default for SwitchBlock<T>

where T::Output: DefaultStorage, BlockData: FromPass<T::Output>,

fn default() -> Self

Returns the “default value” for a type.

impl<T: Apply> ProcessBlock for SwitchBlock<T>

where T::Output: DefaultStorage, BlockData: FromPass<T::Output>,

type Inputs = T

type Output = <T as Apply>::Output

type Parameters = <T as Apply>::Parameters

fn process<'b>( &'b mut self, parameters: &Self::Parameters, _context: &dyn Context, inputs: PassBy<'_, Self::Inputs>, ) -> PassBy<'b, Self::Output>