Enum Count 

pub enum Count {
    Fixed(u64),
    Range((u64, u64)),
}

Represents count specifications for JGD (JSON Generator Definition) entities.

Count defines how many items should be generated for arrays, collections, or repeated elements in JGD schemas. It supports both fixed counts and dynamic ranges, allowing for flexible data generation scenarios.

JGD Schema Usage

In JGD schemas, count specifications control the cardinality of generated data structures. They are commonly used with:

• Array generation (how many array elements to create)
• Entity repetition (how many instances of an entity to generate)
• Collection sizing (dynamic sizing of data collections)

Variants

• Fixed(u64): Generates exactly the specified number of items
• Range((u64, u64)): Generates a random number of items within the range (inclusive)

Serialization Format

The enum uses #[serde(untagged)] for natural JSON representation:

• Fixed count: 42 (just a number)
• Range count: [5, 10] (array with min and max values)

Examples

use jgd_rs::{Count, GetCount, GeneratorConfig};

let mut config = GeneratorConfig::new("EN", Some(42));

// Fixed count - always generates exactly 5 items
let fixed = Count::Fixed(5);
assert_eq!(fixed.count(&mut config), 5);

// Range count - generates between 1 and 10 items
let range = Count::Range((1, 10));
let result = range.count(&mut config);
assert!((1..=10).contains(&result));

JSON Schema Examples

{
  "array": {
    "count": 5,           // Fixed count
    "element": { ... }
  }
}

{
  "array": {
    "count": [1, 10],     // Range count
    "element": { ... }
  }
}

Variants

Fixed(u64)

A fixed count that always generates exactly the specified number of items.

This variant is used when you need a consistent, predictable number of generated items. The value represents the exact count to generate.

JSON Representation

42

Use Cases

• Testing scenarios requiring consistent data sizes
• Schema definitions with fixed requirements
• Performance testing with known data volumes

Range((u64, u64))

A range count that generates a random number of items within the specified bounds.

The tuple contains (min, max) values where both bounds are inclusive. The actual count is randomly determined each time count() is called.

JSON Representation

[5, 15]

Use Cases

• Realistic data generation with natural variation
• Stress testing with variable load sizes
• Simulating real-world data patterns

Trait Implementations

impl Clone for Count

fn clone(&self) -> Count

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Count

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Count

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl GetCount for Count

fn count(&self, config: &mut GeneratorConfig) -> u64

Generates a count value based on the Count variant.

This implementation handles both fixed and range count specifications:

• Fixed: Returns the constant value immediately
• Range: Uses the RNG to generate a random value within the inclusive range

Deterministic Behavior

When the GeneratorConfig is created with a seed, range-based counts will produce deterministic results, which is useful for:

• Testing with reproducible data
• Debugging generation issues
• Creating consistent development datasets

Range Semantics

Range bounds are inclusive on both ends. A range of (5, 10) can generate any value from 5 to 10, including both 5 and 10.

Examples

use jgd_rs::{Count, GetCount, GeneratorConfig};

let mut config = GeneratorConfig::new("EN", Some(42));

// Fixed count always returns the same value
let fixed = Count::Fixed(7);
assert_eq!(fixed.count(&mut config), 7);
assert_eq!(fixed.count(&mut config), 7); // Always 7

// Range count varies within bounds
let range = Count::Range((3, 8));
for _ in 0..10 {
    let result = range.count(&mut config);
    assert!((3..=8).contains(&result));
}