Struct Randomizer

source

pub struct Randomizer {
    pub rng: RefCell<Box<dyn RngCore + Send>>,
    pub seed: u64,
}

Expand description

Struct for managing random number generation, allowing seed control for reproducibility.

Fields§

§rng: RefCell<Box<dyn RngCore + Send>>§seed: u64

Implementations§

source §

impl Randomizer

source

pub fn with_seed(seed: u64) -> Self

Create a new Randomizer with a specified seed.

§Example:

use crazy_train::Randomizer;
let randomizer = Randomizer::with_seed(42);

source

pub fn number_between(&self, min: u32, max: u32) -> u32

Generate a random number between the specified minimum and maximum values (inclusive).

§Example:

use crazy_train::Randomizer;
let randomizer = Randomizer::with_seed(42);
assert_eq!(randomizer.number_between(1,10), 7);

source

pub fn bool(&self) -> bool

Generate a random boolean value (true or false).

§Example:

use crazy_train::Randomizer;
let randomizer = Randomizer::with_seed(42);
assert!(randomizer.bool());

source

pub fn string(&self, def: StringDef) -> StringDefBuilder<'_>

Create a [StringDefBuilder] based on a given StringDef.

§Example:

use crazy_train::{Randomizer, StringDef};
let string_def = StringDef::default();
let randomizer = Randomizer::with_seed(42);
assert_eq!(randomizer.string(string_def.clone()).to_string(), "noqkak");
assert_eq!(randomizer.string(string_def.clone()).include_capital_letters(true).to_string(), "TWdAyN");
assert_eq!(randomizer.string(string_def.clone()).include_unicode(true).to_string(), "kdnfa😩");
assert_eq!(randomizer.string(string_def.clone()).include_numbers(true).to_string(), "0684n0");
assert_eq!(randomizer.string(string_def.clone()).include_symbol(true).to_string(), "=wqf`g");
assert_eq!(randomizer.string(string_def.clone()).length(10).to_string(), "wgavmyyuzw");

Examples found in repository ?

examples/run.rs (line 12)

    fn plan(&self, randomizer: &crazy_train::Randomizer) -> Result<crazy_train::step::Plan> {
        let eco_string = randomizer.string(StringDef::default()).to_string();
        Ok(Plan {
            id: std::any::type_name::<Self>().to_string(),
            command: format!("echo {eco_string}"),
        })
    }

    fn is_success(
        &self,
        execution_result: &crazy_train::executer::Output,
    ) -> Result<bool, &'static str> {
        if execution_result.status_code == Some(0) {
            Ok(true)
        } else {
            Err("status code should be 0")
        }
    }

    fn to_yaml(&self) -> serde_yaml::Value {
        serde_yaml::to_value(self).expect("serialize")
    }
}

#[derive(Serialize, Deserialize)]
struct StepTwo {}

impl StepTrait for StepTwo {
    fn plan(&self, randomizer: &crazy_train::Randomizer) -> Result<crazy_train::step::Plan> {
        let eco_string = randomizer.string(StringDef::default()).to_string();
        Ok(Plan {
            id: std::any::type_name::<Self>().to_string(),
            command: format!("unknown-command {eco_string}"),
        })
    }

source

pub fn path(&self) -> PathBuf

Generate a random path of a specified length.

§Example:

use crazy_train::Randomizer;
use std::path::PathBuf;
let randomizer = Randomizer::with_seed(42);
assert_eq!(randomizer.path(), PathBuf::from("gowqzkza"));

source

pub fn shuffle<T>(&self, items: &[T]) -> Vec<T>
where T: Clone,

Shuffle a slice of items and return a new vector with the shuffled items.

§Example:

use crazy_train::Randomizer;
let randomizer = Randomizer::with_seed(42);
let list = vec![1, 2, 3, 4, 5, 6];
assert_eq!(randomizer.shuffle(&list), vec![1, 5, 6, 3, 2, 4]);

source

pub fn pick_random<T>(&self, items: &[T]) -> Vec<T>
where T: Clone,

Pick a random selection of items from a given slice.

§Example:

use crazy_train::Randomizer;
let randomizer = Randomizer::with_seed(42);
let list = vec![1, 2, 3, 4, 5, 6];
assert_eq!(randomizer.pick_random(&list), vec![2, 6]);