Struct VecMutator

pub struct VecMutator<T: Clone, M: Mutator<T>> {
    pub rng: Rng,
    pub m: M,
    /* private fields */
}

Fields

rng: Rng

m: M

Implementations

impl<T: Clone, M: Mutator<T>> VecMutator<T, M>

pub fn new(mutator: M) -> Self

Trait Implementations

impl<T: Clone, M> Default for VecMutator<T, M>

where M: Default + Mutator<T>,

fn default() -> Self

Returns the “default value” for a type.

impl<T: Clone, M: Mutator<T>> Mutator<Vec<T>> for VecMutator<T, M>

type Cache = VecMutatorCache<<M as Mutator<T>>::Cache>

type MutationStep = MutationStep<<M as Mutator<T>>::MutationStep>

type ArbitraryStep = bool

type UnmutateToken = UnmutateVecToken<T, M>

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

Compute the cache for the given value

fn initial_step_from_value(&self, value: &Vec<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 complexity(&self, value: &Vec<T>, cache: &Self::Cache) -> f64

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

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

fn ordered_mutate( &self, value: &mut Vec<T>, cache: &mut Self::Cache, step: &mut Self::MutationStep, max_cplx: f64, ) -> Option<Self::UnmutateToken>

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

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