1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use rand::Rng;
use rand::thread_rng;
pub struct  EasyRandom{
    small_case_alphabets:Vec<char>,
    upper_case_alphabets:Vec<char>,
    all_case_alphabets:Vec<char>,
    numbers:Vec<char>,
}

impl EasyRandom{
    pub fn new()-> Self{
        EasyRandom{
            small_case_alphabets:('a'..='z').collect(),
            upper_case_alphabets:('A'..'Z').collect(),
            all_case_alphabets:  (b'a'..=b'z').chain(b'A'..=b'Z').map(|c| c as char).collect(),
            numbers:('0'..'9').collect(),
        }
    }
    fn generate_random_index(&mut self, i:usize) -> usize {
        let mut rng = thread_rng();
        rng.gen_range(0..i)
    }

    pub fn exclude_chars(&mut self, chars: &[char]) {
        for &c in chars {
            let exclude_c = c; 
            self.small_case_alphabets.retain(|&x| x != exclude_c);
            self.upper_case_alphabets.retain(|&x| x != exclude_c);
            self.all_case_alphabets.retain(|&x| x != exclude_c);
            self.numbers.retain(|&x| x != exclude_c);
        }
    }
    pub fn exclude_chars_from_vec(&mut self, chars: Vec<char>) {
        for c in chars {
            let exclude_c = c; 
            self.small_case_alphabets.retain(|&x| x != exclude_c);
            self.upper_case_alphabets.retain(|&x| x != exclude_c);
            self.all_case_alphabets.retain(|&x| x != exclude_c);
            self.numbers.retain(|&x| x != exclude_c);
        }
    }
    pub fn generate(&mut self, given: String)->String{

        let mut pattern : String=String::new();
        for c in given.chars(){
            if c.eq(&'a'){
                let n=self.small_case_alphabets.len();
                let i =self.generate_random_index(n);
                let x=self.small_case_alphabets[i];
                pattern.push(x);
            }
            else if c.eq(&'b'){
                let n=self.upper_case_alphabets.len();
                let i =self.generate_random_index(n);
                let x=self.upper_case_alphabets[i];
                pattern.push(x);

            }
            else if c.eq(&'c'){
                let n=self.all_case_alphabets.len();
                let i =self.generate_random_index(n);
                let x=self.all_case_alphabets[i];
                pattern.push(x);

            }
            else if c.eq(&'n'){
                let n=self.numbers.len();
                let i =self.generate_random_index(n);
                let x=self.numbers[i];
                pattern.push(x);
            }
            else if c.eq(&' '){
                pattern.push(' ');
            }
            else{
                pattern= String::from("Please use characters a,b,c,n only to generate");
                break;
            }
        }
        return pattern;
    }
}