sbrd_gen/generator/random_values/
get_value_index_generator.rs

1use crate::builder::GeneratorBuilder;
2use crate::error::{BuildError, GenerateError};
3use crate::generator::{GeneratorBase, Randomizer, ValueGeneratorBase};
4use crate::value::{DataValue, DataValueMap, SbrdInt};
5use crate::GeneratorType;
6
7/// The generator that get available index  of 0-index for value from the values.
8pub struct GetValueIndexGenerator {
9    nullable: bool,
10    values_count: usize,
11}
12
13impl<R: Randomizer + ?Sized> ValueGeneratorBase<R, ()> for GetValueIndexGenerator {
14    fn parse(_input: &str) -> Result<(), BuildError> {
15        Ok(())
16    }
17}
18
19impl<R: Randomizer + ?Sized> GeneratorBase<R> for GetValueIndexGenerator {
20    fn create(builder: GeneratorBuilder) -> Result<Self, BuildError>
21    where
22        Self: Sized,
23    {
24        let GeneratorBuilder {
25            generator_type,
26            nullable,
27            chars,
28            values,
29            filepath,
30            ..
31        } = builder;
32
33        if generator_type != GeneratorType::GetValueIndex {
34            return Err(BuildError::InvalidType(generator_type));
35        }
36
37        let selectable_values =
38            <Self as ValueGeneratorBase<R, ()>>::build_selectable(chars, values, filepath)?;
39
40        Ok(Self {
41            nullable,
42            values_count: selectable_values.len(),
43        })
44    }
45
46    fn is_nullable(&self) -> bool {
47        self.nullable
48    }
49
50    fn generate_without_null(
51        &self,
52        rng: &mut R,
53        _context: &DataValueMap<&str>,
54    ) -> Result<DataValue, GenerateError> {
55        let gen_value = rng.gen_range(0..self.values_count);
56        if gen_value <= SbrdInt::MAX as usize {
57            Ok(DataValue::Int(gen_value as SbrdInt))
58        } else {
59            Err(GenerateError::FailGenerate(
60                "Generated value is too big".to_string(),
61            ))
62        }
63    }
64}