Struct fuzzcheck_mutators::Tuple10Mutator[−][src]

pub struct Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> 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>,
    T5: Clone,
    M5: Mutator<T5>,
    T6: Clone,
    M6: Mutator<T6>,
    T7: Clone,
    M7: Mutator<T7>,
    T8: Clone,
    M8: Mutator<T8>,
    T9: Clone,
    M9: Mutator<T9>,  {
    pub mutator_0: M0,
    pub mutator_1: M1,
    pub mutator_2: M2,
    pub mutator_3: M3,
    pub mutator_4: M4,
    pub mutator_5: M5,
    pub mutator_6: M6,
    pub mutator_7: M7,
    pub mutator_8: M8,
    pub mutator_9: M9,
    // some fields omitted
}

Fields

mutator_0: M0mutator_1: M1mutator_2: M2mutator_3: M3mutator_4: M4mutator_5: M5mutator_6: M6mutator_7: M7mutator_8: M8mutator_9: M9

Implementations

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> 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>, T5: Clone, M5: Mutator<T5>, T6: Clone, M6: Mutator<T6>, T7: Clone, M7: Mutator<T7>, T8: Clone, M8: Mutator<T8>, T9: Clone, M9: Mutator<T9>, [src]

`pub fn new( mutator_0: M0, mutator_1: M1, mutator_2: M2, mutator_3: M3, mutator_4: M4, mutator_5: M5, mutator_6: M6, mutator_7: M7, mutator_8: M8, mutator_9: M9 ) -> Self`[src]

`pub fn replacing_mutator_0<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M, M1, M2, M3, M4, M5, M6, M7, M8, M9> where M: Mutator<T0>,` [src]

`pub fn replacing_mutator_1<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M, M2, M3, M4, M5, M6, M7, M8, M9> where M: Mutator<T1>,` [src]

`pub fn replacing_mutator_2<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M, M3, M4, M5, M6, M7, M8, M9> where M: Mutator<T2>,` [src]

`pub fn replacing_mutator_3<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M, M4, M5, M6, M7, M8, M9> where M: Mutator<T3>,` [src]

`pub fn replacing_mutator_4<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M, M5, M6, M7, M8, M9> where M: Mutator<T4>,` [src]

`pub fn replacing_mutator_5<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M, M6, M7, M8, M9> where M: Mutator<T5>,` [src]

`pub fn replacing_mutator_6<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M, M7, M8, M9> where M: Mutator<T6>,` [src]

`pub fn replacing_mutator_7<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M, M8, M9> where M: Mutator<T7>,` [src]

`pub fn replacing_mutator_8<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M, M9> where M: Mutator<T8>,` [src]

`pub fn replacing_mutator_9<M>( self, mutator: M ) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M> where M: Mutator<T9>,` [src]

Trait Implementations

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> Default for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> 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>, T5: Clone, M5: Mutator<T5>, T6: Clone, M6: Mutator<T6>, T7: Clone, M7: Mutator<T7>, T8: Clone, M8: Mutator<T8>, T9: Clone, M9: Mutator<T9>, M0: Default, M1: Default, M2: Default, M3: Default, M4: Default, M5: Default, M6: Default, M7: Default, M8: Default, M9: Default, [src]

`fn default() -> Self`[src]

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<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> where T: Clone, 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>>, [src]

`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, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache, <M7 as Mutator<T7>>::Cache, <M8 as Mutator<T8>>::Cache, <M9 as Mutator<T9>>::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, <M5 as Mutator<T5>>::MutationStep, <M6 as Mutator<T6>>::MutationStep, <M7 as Mutator<T7>>::MutationStep, <M8 as Mutator<T8>>::MutationStep, <M9 as Mutator<T9>>::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, <M5 as Mutator<T5>>::ArbitraryStep, <M6 as Mutator<T6>>::ArbitraryStep, <M7 as Mutator<T7>>::ArbitraryStep, <M8 as Mutator<T8>>::ArbitraryStep, <M9 as Mutator<T9>>::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, <M5 as Mutator<T5>>::UnmutateToken, <M6 as Mutator<T6>>::UnmutateToken, <M7 as Mutator<T7>>::UnmutateToken, <M8 as Mutator<T8>>::UnmutateToken, <M9 as Mutator<T9>>::UnmutateToken>`

`fn max_complexity(&self) -> f64`[src]

`fn min_complexity(&self) -> f64`[src]

`fn complexity<'a>( &'a self, _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9), cache: &'a Self::Cache ) -> f64`[src]

`fn cache_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9) ) -> Self::Cache`[src]

`fn initial_step_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9) ) -> Self::MutationStep`[src]

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

`fn random_arbitrary(&self, max_cplx: f64) -> (T, Self::Cache)`[src]

`fn ordered_mutate<'a>( &'a self, value: (&'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), cache: &'a mut Self::Cache, step: &'a mut Self::MutationStep, max_cplx: f64 ) -> Option<Self::UnmutateToken>`[src]

`fn random_mutate<'a>( &'a self, value: (&'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), cache: &'a mut Self::Cache, max_cplx: f64 ) -> Self::UnmutateToken`[src]

`fn unmutate<'a>( &'a self, value: (&'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), cache: &'a mut Self::Cache, t: Self::UnmutateToken )`[src]

Auto Trait Implementations

`impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> !RefUnwindSafe for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9>`[src]

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> Send for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> where M0: Send, M1: Send, M2: Send, M3: Send, M4: Send, M5: Send, M6: Send, M7: Send, M8: Send, M9: Send, T0: Send, T1: Send, T2: Send, T3: Send, T4: Send, T5: Send, T6: Send, T7: Send, T8: Send, T9: Send, [src]

`impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> !Sync for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9>`[src]

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> Unpin for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> where M0: Unpin, M1: Unpin, M2: Unpin, M3: Unpin, M4: Unpin, M5: Unpin, M6: Unpin, M7: Unpin, M8: Unpin, M9: Unpin, T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, [src]

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> UnwindSafe for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> where M0: UnwindSafe, M1: UnwindSafe, M2: UnwindSafe, M3: UnwindSafe, M4: UnwindSafe, M5: UnwindSafe, M6: UnwindSafe, M7: UnwindSafe, M8: UnwindSafe, M9: UnwindSafe, T0: UnwindSafe, T1: UnwindSafe, T2: UnwindSafe, T3: UnwindSafe, T4: UnwindSafe, T5: UnwindSafe, T6: UnwindSafe, T7: UnwindSafe, T8: UnwindSafe, T9: UnwindSafe, [src]

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

Struct fuzzcheck_mutators::Tuple10Mutator[−][src]

Fields

Implementations

pub fn new( mutator_0: M0, mutator_1: M1, mutator_2: M2, mutator_3: M3, mutator_4: M4, mutator_5: M5, mutator_6: M6, mutator_7: M7, mutator_8: M8, mutator_9: M9) -> Self[src]

pub fn replacing_mutator_0<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M, M1, M2, M3, M4, M5, M6, M7, M8, M9> where M: Mutator<T0>, [src]

pub fn replacing_mutator_1<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M, M2, M3, M4, M5, M6, M7, M8, M9> where M: Mutator<T1>, [src]

pub fn replacing_mutator_2<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M, M3, M4, M5, M6, M7, M8, M9> where M: Mutator<T2>, [src]

pub fn replacing_mutator_3<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M, M4, M5, M6, M7, M8, M9> where M: Mutator<T3>, [src]

pub fn replacing_mutator_4<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M, M5, M6, M7, M8, M9> where M: Mutator<T4>, [src]

pub fn replacing_mutator_5<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M, M6, M7, M8, M9> where M: Mutator<T5>, [src]

pub fn replacing_mutator_6<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M, M7, M8, M9> where M: Mutator<T6>, [src]

pub fn replacing_mutator_7<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M, M8, M9> where M: Mutator<T7>, [src]

pub fn replacing_mutator_8<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M, M9> where M: Mutator<T8>, [src]

pub fn replacing_mutator_9<M>( self, mutator: M) -> Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M> where M: Mutator<T9>, [src]

Trait Implementations

fn default() -> Self[src]

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, <M5 as Mutator<T5>>::Cache, <M6 as Mutator<T6>>::Cache, <M7 as Mutator<T7>>::Cache, <M8 as Mutator<T8>>::Cache, <M9 as Mutator<T9>>::Cache>

fn max_complexity(&self) -> f64[src]

fn min_complexity(&self) -> f64[src]

fn complexity<'a>( &'a self, _value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9), cache: &'a Self::Cache) -> f64[src]

fn cache_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)) -> Self::Cache[src]

fn initial_step_from_value<'a>( &'a self, value: (&'a T0, &'a T1, &'a T2, &'a T3, &'a T4, &'a T5, &'a T6, &'a T7, &'a T8, &'a T9)) -> Self::MutationStep[src]

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

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

fn ordered_mutate<'a>( &'a self, value: (&'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), cache: &'a mut Self::Cache, step: &'a mut Self::MutationStep, max_cplx: f64) -> Option<Self::UnmutateToken>[src]

fn random_mutate<'a>( &'a self, value: (&'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), cache: &'a mut Self::Cache, max_cplx: f64) -> Self::UnmutateToken[src]

fn unmutate<'a>( &'a self, value: (&'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), cache: &'a mut Self::Cache, t: Self::UnmutateToken)[src]

Auto Trait Implementations

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> !RefUnwindSafe for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9>[src]

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9> !Sync for Tuple10Mutator<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9>[src]

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]