Struct Switch

pub struct Switch<T> { /* private fields */ }

Collection that contains several versions/options of data so you can switch between them in sequential manner. It can be used to produce next data frame based on previous data frame.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::new(2, vec![1, 2, 4]);
if let Some((prev, next)) = switch.iterate() {
    for i in 0..prev.len() {
        // next frame item equals sum of two neighbors.
        let start = i.max(1) - 1;
        let end = (i + 2).min(prev.len());
        next[i] = (start..end).map(|i| prev[i]).sum();
    }
}
assert_eq!(switch.get().unwrap(), &vec![3, 7, 6]);

Implementations

impl<T> Switch<T>

pub fn new(options: usize, value: T) -> Self

where T: Clone,

Creates new switch with number of options and cloned value applied for each of them.

Arguments

• options - Number of options that switch will hold.
• value - Initial value applied for each of options.

Return

Instance of switch.

Example

use psyche_utils::switch::Switch;

let switch = Switch::new(2, vec![1, 2, 4]);

pub fn with_options(options: Vec<T>) -> Self

Creates new switch with initial options values.

Note

Make sure that your options values have same length if they are for example arrays or vectors or any other collection that needs to have same length across each iteration.

Arguments

• options - Initial values applied for options.

Return

Instance of switch.

Example

use psyche_utils::switch::Switch;

let switch = Switch::with_options(vec![
    vec![1, 2, 4],
    vec![3, 7, 6],
]);

pub fn index(&self) -> usize

Gets currently active option index.

Return

Index of currently active switch option.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::new(2, 0);
assert_eq!(switch.index(), 0);
switch.switch();
assert_eq!(switch.index(), 1);
switch.switch();
assert_eq!(switch.index(), 0);

pub fn count(&self) -> usize

Gets number of options that holds.

Return

Number of switch options.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::new(2, 0);
assert_eq!(switch.count(), 2);

pub fn switch(&mut self)

Switches to next option.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::with_options(vec![0, 1]);
assert_eq!(*switch.get().unwrap(), 0);
switch.switch();
assert_eq!(*switch.get().unwrap(), 1);

pub fn iterate(&mut self) -> Option<(&T, &mut T)>

Switches to next option and returns pair of previous and next options.

Return

Pair of previous and next options if holds more than one.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::with_options(vec![0, 1]);
assert_eq!(switch.iterate().unwrap(), (&0, &mut 1));

pub fn get(&self) -> Option<&T>

Gets currently active option if any.

Return

Reference to currently active option.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::with_options(vec![0, 1]);
assert_eq!(switch.get().unwrap(), &0);

pub fn get_mut(&mut self) -> Option<&mut T>

Gets currently active option if any.

Return

Mutable reference to currently active option.

Example

use psyche_utils::switch::Switch;

let mut switch = Switch::with_options(vec![0, 1]);
assert_eq!(switch.get_mut().unwrap(), &mut 0);

Trait Implementations

impl<'de, T> Deserialize<'de> for Switch<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Switch<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.