Struct fuzzcheck::mutators::tuples::Tuple10

pub struct Tuple10<T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static> { /* fields omitted */ }

A marker type implementing RefTypes indicating that a type has the structure of a 10-tuple.

Trait Implementations

impl<T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static> RefTypes for Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>

type Owned = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

type Ref = (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)

type Mut = (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9)

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

impl<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> TupleMutator<T, Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>> for Tuple10Mutator<M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> where
    T: Clone + 'static,
    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>,
    T5: Clone + 'static,
    M5: Mutator<T5>,
    T6: Clone + 'static,
    M6: Mutator<T6>,
    T7: Clone + 'static,
    M7: Mutator<T7>,
    T8: Clone + 'static,
    M8: Mutator<T8>,
    T9: Clone + 'static,
    M9: Mutator<T9>,
    T: TupleStructure<Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>, 

type Cache: Clone

type MutationStep: Clone

type ArbitraryStep: Clone

type UnmutateToken

fn default_arbitrary_step(&self) -> Self::ArbitraryStep

fn complexity<'a>(&self, value: TupleKind::Ref, cache: &'a Self::Cache) -> f64

fn validate_value<'a>(&self, value: TupleKind::Ref) -> Option<Self::Cache>

fn default_mutation_step<'a>(
    &self,
    value: TupleKind::Ref,
    cache: &'a Self::Cache
) -> Self::MutationStep

fn max_complexity(&self) -> f64

fn min_complexity(&self) -> f64

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

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

fn ordered_mutate<'a>(
    &self,
    value: TupleKind::Mut,
    cache: &'a mut Self::Cache,
    step: &'a mut Self::MutationStep,
    max_cplx: f64
) -> Option<(Self::UnmutateToken, f64)>

fn random_mutate<'a>(
    &self,
    value: TupleKind::Mut,
    cache: &'a mut Self::Cache,
    max_cplx: f64
) -> (Self::UnmutateToken, f64)

fn unmutate<'a>(
    &self,
    value: TupleKind::Mut,
    cache: &'a mut Self::Cache,
    t: Self::UnmutateToken
)

type RecursingPartIndex: Clone

fn default_recursing_part_index<'a>(
    &self,
    value: TupleKind::Ref,
    cache: &Self::Cache
) -> Self::RecursingPartIndex

fn recursing_part<'a, V, N>(
    &self,
    parent: &N,
    value: TupleKind::Ref,
    index: &mut Self::RecursingPartIndex
) -> Option<&'a V> where
    V: Clone + 'static,
    N: Mutator<V>, 

impl<T0: 'static, T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static> TupleStructure<Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn get_ref<'a>(
    &'a self
) -> (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)

fn get_mut<'a>(
    &'a mut self
) -> (&'a mut T0, &'a mut T1, &'a mut T2, &'a mut T3, &'a mut T4, &'a mut T5, &'a mut T6, &'a mut T7, &'a mut T8, &'a mut T9)

fn new(t: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self