Trait CombinatorExt 

pub trait CombinatorExt:
    DurationSampler
    + Sized
    + 'static {
    // Provided methods
    fn boxed(self) -> Box<dyn DurationSampler> { ... }
    fn boxed_clonable(self) -> Box<dyn ClonableDurationSampler>
       where Self: Clone + Send + Sync { ... }
    fn map<F>(self, f: F) -> MapSampler<Self, F>
       where F: FnMut(&mut dyn Rng, SimTime, f64) -> f64 { ... }
    fn delay(self, delay: Box<dyn DurationSampler>) -> DelaySampler<Self> { ... }
    fn jitter(self, jitter: Box<dyn DurationSampler>) -> JitterSampler<Self> { ... }
    fn chain<F>(
        self,
        sampler: Box<dyn DurationSampler>,
        f: F,
    ) -> ChainSampler<Self, F>
       where F: FnMut(&mut dyn Rng, SimTime, f64, f64) -> f64 { ... }
    fn aggregate<F>(
        self,
        others: impl IntoIterator<Item = Box<dyn DurationSampler>>,
        f: F,
    ) -> AggregateSampler<F>
       where F: FnMut(&mut dyn Rng, SimTime, Vec<f64>) -> f64 { ... }
    fn aggregate_builder(self) -> AggregateBuilder { ... }
    fn clamp(self, min: f64, max: f64) -> ClampSampler<Self> { ... }
    fn ensure_non_negative<F>(
        self,
        limit_try_count: u8,
        fallback: F,
    ) -> EnsureNonNegativeSampler<Self, F>
       where F: FnMut(&mut dyn Rng, SimTime) -> Duration { ... }
}

An extension trait for DurationSampler that provides fluent combinator methods for creating and composing complex duration sampling logic.

Provided Methods

fn boxed(self) -> Box<dyn DurationSampler>

Boxes the sampler into a Box<dyn DurationSampler> to erase its concrete type.

fn boxed_clonable(self) -> Box<dyn ClonableDurationSampler>

where Self: Clone + Send + Sync,

Boxes the sampler as a cloneable trait object. Requires the underlying sampler to be Clone, Send, and Sync.

fn map<F>(self, f: F) -> MapSampler<Self, F>

where F: FnMut(&mut dyn Rng, SimTime, f64) -> f64,

Transforms the output of this sampler using the provided closure f.

fn delay(self, delay: Box<dyn DurationSampler>) -> DelaySampler<Self>

Adds a delay to the result of this sampler using another sampler for the duration.

fn jitter(self, jitter: Box<dyn DurationSampler>) -> JitterSampler<Self>

Adds a jitter (noise) to the result of this sampler using another sampler for the variation.

fn chain<F>( self, sampler: Box<dyn DurationSampler>, f: F, ) -> ChainSampler<Self, F>

where F: FnMut(&mut dyn Rng, SimTime, f64, f64) -> f64,

Chains this sampler with another, combining their outputs using the provided closure f.

fn aggregate<F>( self, others: impl IntoIterator<Item = Box<dyn DurationSampler>>, f: F, ) -> AggregateSampler<F>

where F: FnMut(&mut dyn Rng, SimTime, Vec<f64>) -> f64,

Aggregates the results of this sampler and a collection of others into a single value using the provided closure f.

fn aggregate_builder(self) -> AggregateBuilder

Returns an AggregateBuilder initialized with this sampler, allowing for a more flexible construction of aggregate samplers.

fn clamp(self, min: f64, max: f64) -> ClampSampler<Self>

Clamps the output of this sampler within the range [min, max].

fn ensure_non_negative<F>( self, limit_try_count: u8, fallback: F, ) -> EnsureNonNegativeSampler<Self, F>

where F: FnMut(&mut dyn Rng, SimTime) -> Duration,

Ensures the sampled duration is non-negative.

If the value remains negative after limit_try_count attempts, the fallback closure is invoked.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T: DurationSampler + Sized + 'static> CombinatorExt for T