Struct DiscontinuousTransitioner 

pub struct DiscontinuousTransitioner {
    state_buffer: Vec<Arc<IterationState>>,
    time_per_flomap: f64,
    current_index: usize,
}

A transitioner that handles discontinuous transitions between flow-map states.

Each IterationState in state_buffer represents a flow-map state, and consecutive states are separated by a fixed duration time_per_flomap.

Behavior

• The transitioner does not maintain an internal time counter; calling advance or advance_arc with the same current_time multiple times are idempotent and always returns the correct state corresponding to current_time.
• Delta time argument is therefore not used
• Transitions are discontinuous: as current_time crosses multiples of time_per_flomap, current_index jumps directly to the correct state in state_buffer.
• Iteration is cyclic: when the current_index reaches the last state, it wraps around to index 0. For example, with 15 states, iteration goes: 14 -> 0 -> 1 -> ....
• current_index always points to the active flow-map state based on current_time.

Fields

• state_buffer — A Vec<Arc<IterationState>> containing all flow-map states.
• time_per_flomap — Duration of each flow-map in seconds (or any consistent time unit).
• current_index — The index of the currently active flow-map state in state_buffer.

Example

let transitioner = DiscontinuousTransitioner {
    state_buffer: vec![Arc::new(state1), Arc::new(state2), Arc::new(state3)],
    time_per_flomap: 0.5,
    current_index: 0,
};

// current_time = 1.3 -> index = 2 (3rd state)
let state = transitioner.advance(1.3, 0.1);

// current_time = 1.6 -> cycles back to index 0 (if 3 states)
let state = transitioner.advance(1.6, 0.1);

Fields

state_buffer: Vec<Arc<IterationState>>

time_per_flomap: f64

current_index: usize

Implementations

impl DiscontinuousTransitioner

fn index_for_time(&self, t: f64) -> usize

fn get_index_and_state( &mut self, current_time: f64, ) -> (usize, &Arc<IterationState>)

fn get_state(&mut self, current_time: f64) -> &Arc<IterationState>

pub fn advance_mut( &mut self, state: &mut Arc<IterationState>, current_time: f64, _time_step: f64, ) -> bool

Trait Implementations

impl FlowMapTransitioner for DiscontinuousTransitioner

fn advance(&mut self, current_time: f64, _time_step: f64) -> &IterationState

Advances the internal state according to current_time and time_step, and returns a borrowed reference to the active IterationState.

fn advance_arc( &mut self, current_time: f64, _time_step: f64, ) -> Arc<IterationState>

Same as [advance], but returns an owned Arc<IterationState>.

fn need_advance(&self, current_time: f64, _time_step: f64) -> bool

Returns true if the flow-map index should advance when evaluating the given current_time and time_step.

fn size(&self) -> usize

Returns the number of flow-map states stored in this transitioner.

fn get_current_arc(&self) -> Arc<IterationState>

Returns the current state as an owned Arc<IterationState>.

fn get_current(&self) -> &IterationState

Returns the current state as a borrowed reference.

fn get_at(&self, idx: usize) -> Option<Arc<IterationState>>

Retrieves the state at the given buffer index as an owned Arc.

fn new(time_per_flomap: f64, buffer: FlowMapBuffer) -> Self

Constructs a new transitioner from the duration of each flow-map (time_per_flomap) and a validated FlowMapBuffer.

fn from_case(root: &str, case: &CMCase) -> Result<Self, DataError>

where Self: Sized,

Constructs a transitioner by loading flow-map descriptors from disk using the provided case definition.