Trait smoke::generator::Generator

pub trait Generator {
    type Item;
    fn gen(&self, r: &mut R) -> Self::Item;

    fn map<O, F>(self, f: F) -> Map<Self, F>
    where
        Self: Sized,
        F: Fn(Self::Item) -> O,
    { ... }
    fn such_that<F>(self, f: F) -> SuchThat<Self, F>
    where
        Self: Sized,
        F: Fn(Self::Item) -> bool + Clone,
    { ... }
    fn and<G>(self, other: G) -> And<Self, G>
    where
        Self: Sized,
    { ... }
    fn or<G>(self, other: G) -> Or<Self, G>
    where
        Self: Sized,
        G: Generator<Item = Self::Item>,
    { ... }
    fn into_boxed(self) -> BoxGenerator<Self::Item>
    where
        Self: Sized + 'static,
    { ... }
}

Generator for an Item

The interface is very similar to an Iterator, except next is gen

Associated Types

type Item

Type generated by the generator

Loading content...

Required methods

fn gen(&self, r: &mut R) -> Self::Item

Generate the next item

Loading content...

Provided methods

fn map<O, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: Fn(Self::Item) -> O, 

Map the output of a generator through a function

use smoke::{Generator, generator::num};

let generator = num::<u32>().map(|n| n + 1);

fn such_that<F>(self, f: F) -> SuchThat<Self, F> where
    Self: Sized,
    F: Fn(Self::Item) -> bool + Clone, 

Filter the generated items such that only the item that matches the predicate 'f' are returned.

Due to being an user controlled callback, it's not recommended to do heavy filtering with this function and instead use a generator that generate data that is closer to the end result. A general rule of thumb, is that if the callback accept less than half the generated value, then it should probably be refined at the source generator.

use smoke::{Generator, generator::range};
// u32 number between 1 and 1000 that are odd only
let odd_gen = range(1u32..1000).such_that(|n| (n & 0x1) == 1);

fn and<G>(self, other: G) -> And<Self, G> where
    Self: Sized, 

Combine two arbitrary generators into one that generate tuple item of both generators, transforming generator for A and generator for B into one generator of (A,B)

use smoke::{Generator, generator::{Num, num}};

let generator_a : Num<u32> = num();
let generator_b : Num<u64> = num();

let generator = generator_a.and(generator_b);

fn or<G>(self, other: G) -> Or<Self, G> where
    Self: Sized,
    G: Generator<Item = Self::Item>, 

This generator or another one.

It's not recommended to use this combinator to chain more than one generator, as the generator on the "left" will have a 1/2 handicapped at each iteration.

Prefered choose() to do a unbiased choice or frequency() to control the distribution between generator.

fn into_boxed(self) -> BoxGenerator<Self::Item> where
    Self: Sized + 'static, 

Box a generator into a monomorphic fixed-sized type, that is easier to handle

Loading content...

Implementors

impl<A, B, T> Generator for Or<A, B> where
    A: Generator<Item = T>,
    B: Generator<Item = T>, 

type Item = T

fn gen(&self, r: &mut R) -> Self::Item

impl<A, B, T, U> Generator for And<A, B> where
    A: Generator<Item = T>,
    B: Generator<Item = U>, 

type Item = (T, U)

fn gen(&self, r: &mut R) -> Self::Item

impl<G1, G2, F> Generator for Depends<G1, F> where
    G1: Generator,
    G2: Generator,
    F: Fn(&G1::Item) -> G2, 

type Item = (G1::Item, G2::Item)

fn gen(&self, r: &mut R) -> Self::Item

impl<G: Generator, F> Generator for SuchThat<G, F> where
    F: Fn(&G::Item) -> bool + Clone, 

type Item = G::Item

fn gen(&self, r: &mut R) -> Self::Item

impl<O, G1: Generator, G2: Generator, F> Generator for Product2<G1, G2, F> where
    F: Fn(G1::Item, G2::Item) -> O + Clone, 

type Item = O

fn gen(&self, r: &mut R) -> Self::Item

impl<O, G1: Generator, G2: Generator, G3: Generator, F> Generator for Product3<G1, G2, G3, F> where
    F: Fn(G1::Item, G2::Item, G3::Item) -> O + Clone, 

type Item = O

fn gen(&self, r: &mut R) -> Self::Item

impl<O, G: Generator, F> Generator for Map<G, F> where
    F: Fn(G::Item) -> O + Clone, 

type Item = O

fn gen(&self, r: &mut R) -> O

impl<T> Generator for BoxGenerator<T>

type Item = T

fn gen(&self, r: &mut R) -> Self::Item

fn into_boxed(self) -> BoxGenerator<Self::Item>

impl<T> Generator for Choose<T>

type Item = T

fn gen(&self, r: &mut R) -> Self::Item

impl<T> Generator for Frequency<T>

type Item = T

fn gen(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array10<G> where
    G: Generator<Item = T>, 

type Item = [T; 10]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array11<G> where
    G: Generator<Item = T>, 

type Item = [T; 11]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array12<G> where
    G: Generator<Item = T>, 

type Item = [T; 12]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array128<G> where
    G: Generator<Item = T>, 

type Item = [T; 128]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array13<G> where
    G: Generator<Item = T>, 

type Item = [T; 13]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array14<G> where
    G: Generator<Item = T>, 

type Item = [T; 14]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array15<G> where
    G: Generator<Item = T>, 

type Item = [T; 15]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array16<G> where
    G: Generator<Item = T>, 

type Item = [T; 16]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array17<G> where
    G: Generator<Item = T>, 

type Item = [T; 17]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array18<G> where
    G: Generator<Item = T>, 

type Item = [T; 18]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array19<G> where
    G: Generator<Item = T>, 

type Item = [T; 19]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array2<G> where
    G: Generator<Item = T>, 

type Item = [T; 2]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array20<G> where
    G: Generator<Item = T>, 

type Item = [T; 20]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array21<G> where
    G: Generator<Item = T>, 

type Item = [T; 21]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array22<G> where
    G: Generator<Item = T>, 

type Item = [T; 22]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array23<G> where
    G: Generator<Item = T>, 

type Item = [T; 23]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array24<G> where
    G: Generator<Item = T>, 

type Item = [T; 14]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array25<G> where
    G: Generator<Item = T>, 

type Item = [T; 25]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array26<G> where
    G: Generator<Item = T>, 

type Item = [T; 26]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array27<G> where
    G: Generator<Item = T>, 

type Item = [T; 27]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array28<G> where
    G: Generator<Item = T>, 

type Item = [T; 28]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array29<G> where
    G: Generator<Item = T>, 

type Item = [T; 29]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array3<G> where
    G: Generator<Item = T>, 

type Item = [T; 3]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array30<G> where
    G: Generator<Item = T>, 

type Item = [T; 30]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array31<G> where
    G: Generator<Item = T>, 

type Item = [T; 31]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array32<G> where
    G: Generator<Item = T>, 

type Item = [T; 32]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array4<G> where
    G: Generator<Item = T>, 

type Item = [T; 4]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array5<G> where
    G: Generator<Item = T>, 

type Item = [T; 5]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array6<G> where
    G: Generator<Item = T>, 

type Item = [T; 6]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array64<G> where
    G: Generator<Item = T>, 

type Item = [T; 64]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array7<G> where
    G: Generator<Item = T>, 

type Item = [T; 7]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array8<G> where
    G: Generator<Item = T>, 

type Item = [T; 8]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, G> Generator for Array9<G> where
    G: Generator<Item = T>, 

type Item = [T; 9]

fn gen<'a>(&self, r: &mut R) -> Self::Item

impl<T, SZ, G> Generator for Vector<SZ, G> where
    SZ: Generator<Item = usize>,
    G: Generator<Item = T>, 

type Item = Vec<T>

fn gen(&self, r: &mut R) -> Self::Item

impl<T: NumPrimitive> Generator for Num<T>

type Item = T

fn gen(&self, r: &mut R) -> T

impl<T: NumPrimitive> Generator for NumRange<T>

type Item = T

fn gen(&self, r: &mut R) -> T

impl<T: Clone> Generator for Constant<T>

type Item = T

fn gen(&self, _: &mut R) -> Self::Item

impl<T: Clone> Generator for OneOf<T>

type Item = T

fn gen(&self, r: &mut R) -> Self::Item

Loading content...