rrandgen 0.1.0

A simple library for generating random numbers with specified length and count
Documentation
//! # rrandgen
//! 
//! A simple library for generating random numbers with specified length and count.
//! 
//! ## Examples
//! 
//! ```
//! use rrandgen::{RandomGenerator, generate_random_numbers};
//! 
//! // Create a generator
//! let mut generator = RandomGenerator::new();
//! 
//! // Generate 5 random numbers with 4 digits each
//! let numbers = generator.generate(4, 5);
//! println!("{:?}", numbers);
//! 
//! // Or use the convenience function
//! let numbers = generate_random_numbers(3, 10);
//! println!("{:?}", numbers);
//! ```

use rand::Rng;

/// A random number generator that creates numbers with specified length and count.
pub struct RandomGenerator {
    rng: rand::rngs::ThreadRng,
}

impl RandomGenerator {
    /// Creates a new RandomGenerator instance.
    pub fn new() -> Self {
        Self {
            rng: rand::thread_rng(),
        }
    }

    /// Generates random numbers with the specified length and count.
    /// 
    /// # Arguments
    /// 
    /// * `length` - The number of digits in each generated number
    /// * `count` - The number of random numbers to generate
    /// 
    /// # Returns
    /// 
    /// A vector containing the generated random numbers
    /// 
    /// # Examples
    /// 
    /// ```
    /// use rrandgen::RandomGenerator;
    /// 
    /// let mut generator = RandomGenerator::new();
    /// let numbers = generator.generate(3, 5);
    /// assert_eq!(numbers.len(), 5);
    /// for num in &numbers {
    ///     assert!(*num >= 100 && *num <= 999); // 3-digit numbers
    /// }
    /// ```
    pub fn generate(&mut self, length: usize, count: usize) -> Vec<u64> {
        if length == 0 || count == 0 {
            return Vec::new();
        }

        let mut result = Vec::with_capacity(count);
        
        // Calculate the range for numbers with the specified length
        let min_value = if length == 1 { 0 } else { 10_u64.pow((length - 1) as u32) };
        let max_value = 10_u64.pow(length as u32) - 1;

        for _ in 0..count {
            let random_num = self.rng.gen_range(min_value..=max_value);
            result.push(random_num);
        }

        result
    }

    /// Generates random numbers as strings with the specified length and count.
    /// This ensures leading zeros are preserved for numbers shorter than the specified length.
    /// 
    /// # Arguments
    /// 
    /// * `length` - The number of digits in each generated number
    /// * `count` - The number of random numbers to generate
    /// 
    /// # Returns
    /// 
    /// A vector containing the generated random numbers as strings
    /// 
    /// # Examples
    /// 
    /// ```
    /// use rrandgen::RandomGenerator;
    /// 
    /// let mut generator = RandomGenerator::new();
    /// let numbers = generator.generate_strings(4, 3);
    /// assert_eq!(numbers.len(), 3);
    /// for num_str in &numbers {
    ///     assert_eq!(num_str.len(), 4);
    /// }
    /// ```
    pub fn generate_strings(&mut self, length: usize, count: usize) -> Vec<String> {
        if length == 0 || count == 0 {
            return Vec::new();
        }

        let mut result = Vec::with_capacity(count);
        
        for _ in 0..count {
            let mut num_str = String::new();
            for _ in 0..length {
                let digit = self.rng.gen_range(0..=9);
                num_str.push_str(&digit.to_string());
            }
            result.push(num_str);
        }

        result
    }
}

impl Default for RandomGenerator {
    fn default() -> Self {
        Self::new()
    }
}

/// Convenience function to generate random numbers with specified length and count.
/// 
/// # Arguments
/// 
/// * `length` - The number of digits in each generated number
/// * `count` - The number of random numbers to generate
/// 
/// # Returns
/// 
/// A vector containing the generated random numbers
/// 
/// # Examples
/// 
/// ```
/// use rrandgen::generate_random_numbers;
/// 
/// let numbers = generate_random_numbers(2, 5);
/// assert_eq!(numbers.len(), 5);
/// for num in &numbers {
///     assert!(*num >= 10 && *num <= 99); // 2-digit numbers
/// }
/// ```
pub fn generate_random_numbers(length: usize, count: usize) -> Vec<u64> {
    let mut generator = RandomGenerator::new();
    generator.generate(length, count)
}

/// Convenience function to generate random numbers as strings with specified length and count.
/// 
/// # Arguments
/// 
/// * `length` - The number of digits in each generated number
/// * `count` - The number of random numbers to generate
/// 
/// # Returns
/// 
/// A vector containing the generated random numbers as strings
/// 
/// # Examples
/// 
/// ```
/// use rrandgen::generate_random_strings;
/// 
/// let numbers = generate_random_strings(3, 4);
/// assert_eq!(numbers.len(), 4);
/// for num_str in &numbers {
///     assert_eq!(num_str.len(), 3);
/// }
/// ```
pub fn generate_random_strings(length: usize, count: usize) -> Vec<String> {
    let mut generator = RandomGenerator::new();
    generator.generate_strings(length, count)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_generate_random_numbers() {
        let numbers = generate_random_numbers(3, 5);
        assert_eq!(numbers.len(), 5);
        
        for num in &numbers {
            assert!(*num >= 100 && *num <= 999);
        }
    }

    #[test]
    fn test_generate_single_digit() {
        let numbers = generate_random_numbers(1, 10);
        assert_eq!(numbers.len(), 10);
        
        for num in &numbers {
            assert!(*num <= 9);
        }
    }

    #[test]
    fn test_generate_zero_count() {
        let numbers = generate_random_numbers(3, 0);
        assert_eq!(numbers.len(), 0);
    }

    #[test]
    fn test_generate_zero_length() {
        let numbers = generate_random_numbers(0, 5);
        assert_eq!(numbers.len(), 0);
    }

    #[test]
    fn test_generator_struct() {
        let mut generator = RandomGenerator::new();
        let numbers = generator.generate(4, 3);
        assert_eq!(numbers.len(), 3);
        
        for num in &numbers {
            assert!(*num >= 1000 && *num <= 9999);
        }
    }

    #[test]
    fn test_generate_strings() {
        let numbers = generate_random_strings(4, 5);
        assert_eq!(numbers.len(), 5);
        
        for num_str in &numbers {
            assert_eq!(num_str.len(), 4);
            assert!(num_str.chars().all(|c| c.is_ascii_digit()));
        }
    }

    #[test]
    fn test_generator_strings_method() {
        let mut generator = RandomGenerator::new();
        let numbers = generator.generate_strings(3, 2);
        assert_eq!(numbers.len(), 2);
        
        for num_str in &numbers {
            assert_eq!(num_str.len(), 3);
            assert!(num_str.chars().all(|c| c.is_ascii_digit()));
        }
    }
}