Struct TupleMutatorWrapper 

pub struct TupleMutatorWrapper<T, M, TupleKind>
where
    T: Clone + 'static + TupleStructure<TupleKind>,
    TupleKind: RefTypes,
    M: TupleMutator<T, TupleKind>,
{
    pub mutator: M,
    /* private fields */
}

Fields

mutator: M

Implementations

impl<T, M, TupleKind> TupleMutatorWrapper<T, M, TupleKind>

where T: Clone + 'static + TupleStructure<TupleKind>, TupleKind: RefTypes, M: TupleMutator<T, TupleKind>,

pub fn new(mutator: M) -> Self

Trait Implementations

impl<T, M, TupleKind> Default for TupleMutatorWrapper<T, M, TupleKind>

where T: Clone + 'static + TupleStructure<TupleKind>, TupleKind: RefTypes, M: TupleMutator<T, TupleKind> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T, M, TupleKind> Mutator<T> for TupleMutatorWrapper<T, M, TupleKind>

where T: Clone + 'static + TupleStructure<TupleKind>, TupleKind: RefTypes, M: TupleMutator<T, TupleKind>,

type Cache = <M as TupleMutator<T, TupleKind>>::Cache

type MutationStep = <M as TupleMutator<T, TupleKind>>::MutationStep

type ArbitraryStep = <M as TupleMutator<T, TupleKind>>::ArbitraryStep

type UnmutateToken = <M as TupleMutator<T, TupleKind>>::UnmutateToken

fn complexity(&self, value: &T, cache: &Self::Cache) -> f64

fn cache_from_value(&self, value: &T) -> Self::Cache

Compute the cache for the given value

fn initial_step_from_value(&self, value: &T) -> Self::MutationStep

Compute the initial mutation step for the given value

fn max_complexity(&self) -> f64

The maximum complexity of an input of this type

fn min_complexity(&self) -> f64

The minimum complexity of an input of this type

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( &self, value: &mut T, cache: &mut Self::Cache, step: &mut Self::MutationStep, max_cplx: f64, ) -> Option<Self::UnmutateToken>

fn random_mutate( &self, value: &mut T, cache: &mut Self::Cache, max_cplx: f64, ) -> Self::UnmutateToken

fn unmutate( &self, value: &mut T, cache: &mut Self::Cache, t: Self::UnmutateToken, )