datagen_rs/schema/
array.rs

1use crate::schema::any_value::AnyValue;
2use crate::schema::transform::Transform;
3#[cfg(feature = "schema")]
4use schemars::JsonSchema;
5#[cfg(feature = "serialize")]
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone)]
9#[cfg_attr(feature = "schema", derive(JsonSchema))]
10#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
11#[cfg_attr(feature = "serialize", serde(untagged, deny_unknown_fields))]
12pub enum ArrayLength {
13    Constant { value: u32 },
14    Random { min: u32, max: u32 },
15}
16
17#[derive(Debug, Clone)]
18#[cfg_attr(feature = "schema", derive(JsonSchema))]
19#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
20pub struct Array {
21    pub length: ArrayLength,
22    pub items: AnyValue,
23    pub transform: Option<Vec<Transform>>,
24}
25
26#[cfg(feature = "generate")]
27pub mod generate {
28    use crate::generate::current_schema::CurrentSchemaRef;
29    use crate::generate::generated_schema::generate::IntoGeneratedArc;
30    use crate::generate::generated_schema::{GeneratedSchema, IntoRandom};
31    use crate::generate::schema_mapper::MapSchema;
32    use crate::schema::array::{Array, ArrayLength};
33    use crate::schema::transform::Transform;
34    use crate::util::types::Result;
35    use rand::Rng;
36    use std::sync::Arc;
37
38    impl ArrayLength {
39        pub fn get_length(&self) -> u32 {
40            match self {
41                ArrayLength::Constant { value } => *value,
42                ArrayLength::Random { min, max } => {
43                    let mut rng = rand::thread_rng();
44                    rng.gen_range(*min..=*max)
45                }
46            }
47        }
48    }
49
50    impl IntoGeneratedArc for Array {
51        fn into_generated_arc(self, schema: CurrentSchemaRef) -> Result<Arc<GeneratedSchema>> {
52            let length = self.length.get_length();
53            schema.map_array(length as _, self.items, None, false, |cur, value| {
54                value.into_random(cur.clone())
55            })
56        }
57
58        fn get_transform(&self) -> Option<Vec<Transform>> {
59            self.transform.clone()
60        }
61    }
62}