Struct Tuple5Mutator

pub struct Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4>
where
    T0: Clone,
    M0: Mutator<T0>,
    T1: Clone,
    M1: Mutator<T1>,
    T2: Clone,
    M2: Mutator<T2>,
    T3: Clone,
    M3: Mutator<T3>,
    T4: Clone,
    M4: Mutator<T4>,
{
    pub mutator_0: M0,
    pub mutator_1: M1,
    pub mutator_2: M2,
    pub mutator_3: M3,
    pub mutator_4: M4,
    /* private fields */
}

Fields

mutator_0: M0

mutator_1: M1

mutator_2: M2

mutator_3: M3

mutator_4: M4

Implementations

impl<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4> Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4>

where T0: Clone, M0: Mutator<T0>, T1: Clone, M1: Mutator<T1>, T2: Clone, M2: Mutator<T2>, T3: Clone, M3: Mutator<T3>, T4: Clone, M4: Mutator<T4>,

pub fn new( mutator_0: M0, mutator_1: M1, mutator_2: M2, mutator_3: M3, mutator_4: M4, ) -> Self

pub fn replacing_mutator_0<M>( self, mutator: M, ) -> Tuple5Mutator<T0, T1, T2, T3, T4, M, M1, M2, M3, M4>

where M: Mutator<T0>,

pub fn replacing_mutator_1<M>( self, mutator: M, ) -> Tuple5Mutator<T0, T1, T2, T3, T4, M0, M, M2, M3, M4>

where M: Mutator<T1>,

pub fn replacing_mutator_2<M>( self, mutator: M, ) -> Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M, M3, M4>

where M: Mutator<T2>,

pub fn replacing_mutator_3<M>( self, mutator: M, ) -> Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M, M4>

where M: Mutator<T3>,

pub fn replacing_mutator_4<M>( self, mutator: M, ) -> Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M3, M>

where M: Mutator<T4>,

Trait Implementations

impl<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4> Default for Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4>

where T0: Clone, M0: Mutator<T0> + Default, T1: Clone, M1: Mutator<T1> + Default, T2: Clone, M2: Mutator<T2> + Default, T3: Clone, M3: Mutator<T3> + Default, T4: Clone, M4: Mutator<T4> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, T0, T1, T2, T3, T4, M0, M1, M2, M3, M4> TupleMutator<T, Tuple5<T0, T1, T2, T3, T4>> for Tuple5Mutator<T0, T1, T2, T3, T4, M0, M1, M2, M3, M4>

where T: Clone + TupleStructure<Tuple5<T0, T1, T2, T3, T4>>, T0: Clone + 'static, M0: Mutator<T0>, T1: Clone + 'static, M1: Mutator<T1>, T2: Clone + 'static, M2: Mutator<T2>, T3: Clone + 'static, M3: Mutator<T3>, T4: Clone + 'static, M4: Mutator<T4>,

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache, <M3 as Mutator<T3>>::Cache, <M4 as Mutator<T4>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep, <M3 as Mutator<T3>>::MutationStep, <M4 as Mutator<T4>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep, <M3 as Mutator<T3>>::ArbitraryStep, <M4 as Mutator<T4>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken, <M3 as Mutator<T3>>::UnmutateToken, <M4 as Mutator<T4>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

fn complexity<'a>( &'a self, _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4), cache: &'a Self::Cache, ) -> f64

fn cache_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4), ) -> Self::Cache

fn initial_step_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4), ) -> Self::MutationStep

fn ordered_arbitrary( &self, step: &mut Self::ArbitraryStep, max_cplx: f64, ) -> Option<(T, Self::Cache)>

fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)

fn ordered_mutate<'a>( &'a self, value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4), cache: &'a mut Self::Cache, step: &'a mut Self::MutationStep, max_cplx: f64, ) -> Option<Self::UnmutateToken>

fn random_mutate<'a>( &'a self, value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4), cache: &'a mut Self::Cache, max_cplx: f64, ) -> Self::UnmutateToken

fn unmutate<'a>( &'a self, value: (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4), cache: &'a mut Self::Cache, t: Self::UnmutateToken, )