Struct Tuple3

pub struct Tuple3<T0: 'static, T1: 'static, T2: 'static> { /* private fields */ }

Trait Implementations

impl<T0: 'static, T1: 'static, T2: 'static> RefTypes for Tuple3<T0, T1, T2>

type Owned = (T0, T1, T2)

type Ref<'a> = (&'a T0, &'a T1, &'a T2)

type Mut<'a> = (&'a mut T0, &'a mut T1, &'a mut T2)

fn get_ref_from_mut<'a>(v: &'a Self::Mut<'a>) -> Self::Ref<'a>

impl<T, T0, T1, T2, M0, M1, M2> TupleMutator<T, Tuple3<T0, T1, T2>> for Tuple3Mutator<T0, T1, T2, M0, M1, M2>

where T: Clone + TupleStructure<Tuple3<T0, T1, T2>>, T0: Clone + 'static, M0: Mutator<T0>, T1: Clone + 'static, M1: Mutator<T1>, T2: Clone + 'static, M2: Mutator<T2>,

type Cache = Cache<<M0 as Mutator<T0>>::Cache, <M1 as Mutator<T1>>::Cache, <M2 as Mutator<T2>>::Cache>

type MutationStep = MutationStep<<M0 as Mutator<T0>>::MutationStep, <M1 as Mutator<T1>>::MutationStep, <M2 as Mutator<T2>>::MutationStep>

type ArbitraryStep = ArbitraryStep<<M0 as Mutator<T0>>::ArbitraryStep, <M1 as Mutator<T1>>::ArbitraryStep, <M2 as Mutator<T2>>::ArbitraryStep>

type UnmutateToken = UnmutateToken<<M0 as Mutator<T0>>::UnmutateToken, <M1 as Mutator<T1>>::UnmutateToken, <M2 as Mutator<T2>>::UnmutateToken>

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

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

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

fn initial_step_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2), ) -> 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), 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), 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), cache: &'a mut Self::Cache, t: Self::UnmutateToken, )

impl<T0: 'static, T1: 'static, T2: 'static> TupleStructure<Tuple3<T0, T1, T2>> for (T0, T1, T2)

fn get_ref<'a>(&'a self) -> (&'a T0, &'a T1, &'a T2)

fn get_mut<'a>(&'a mut self) -> (&'a mut T0, &'a mut T1, &'a mut T2)

fn new(t: (T0, T1, T2)) -> Self