#![no_std]
extern crate no_std_compat as std;
use std::prelude::v1::*;
#[cfg(feature = "words")]
mod words;
#[cfg(feature = "nouns")]
mod nouns;
#[cfg(feature = "adjectives")]
mod adjectives;
#[cfg(feature = "names")]
mod names;
#[cfg(feature = "first_names")]
mod first_names;
#[cfg(feature = "last_names")]
mod last_names;
#[cfg(any(feature = "core", feature = "send_only"))]
pub use rand::rngs::StdRng;
#[cfg(any(feature = "core"))]
pub use rand::{
rngs::{ ThreadRng, OsRng }
};
#[cfg(feature = "custom")]
pub use getrandom::register_custom_getrandom;
#[cfg(any(feature = "first_names", feature = "last_names"))]
use inflections::Inflect;
pub use rand::{
Rng, SeedableRng, RngCore, CryptoRng, Error
};
#[cfg(feature = "custom")]
#[derive(Clone)]
pub struct CustomRng {
rng: std::sync::Arc<spin::mutex::Mutex<dyn RngCore>>
}
#[cfg(feature = "custom")]
impl CustomRng {
pub fn new(rng: impl RngCore + 'static) -> Self {
Self {
rng: std::sync::Arc::new(spin::mutex::Mutex::new(rng))
}
}
}
#[cfg(feature = "custom")]
impl RngCore for CustomRng {
fn next_u32(&mut self) -> u32 {
let mut rl = self.rng.lock();
rl.next_u32()
}
fn next_u64(&mut self) -> u64 {
let mut rl = self.rng.lock();
rl.next_u64()
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
let mut rl = self.rng.lock();
rl.fill_bytes(dest)
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
let mut rl = self.rng.lock();
rl.try_fill_bytes(dest)
}
}
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
pub trait RngCrypto: RngCore + CryptoRng {}
#[derive(Clone)]
#[cfg(feature = "custom")]
pub struct CustomCryptoRng {
rng: std::sync::Arc<spin::mutex::Mutex<dyn RngCrypto>>
}
#[cfg(feature = "custom")]
impl CustomCryptoRng {
pub fn new(rng: impl RngCrypto + 'static) -> Self {
Self {
rng: std::sync::Arc::new(spin::mutex::Mutex::new(rng))
}
}
}
#[cfg(feature = "custom")]
impl RngCrypto for CustomCryptoRng {}
#[cfg(feature = "custom")]
impl CryptoRng for CustomCryptoRng {}
#[cfg(feature = "custom")]
impl RngCore for CustomCryptoRng {
fn next_u32(&mut self) -> u32 {
let mut rl = self.rng.lock();
rl.next_u32()
}
fn next_u64(&mut self) -> u64 {
let mut rl = self.rng.lock();
rl.next_u64()
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
let mut rl = self.rng.lock();
rl.fill_bytes(dest)
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
let mut rl = self.rng.lock();
rl.try_fill_bytes(dest)
}
}
#[derive(Clone)]
pub enum RNG {
#[cfg(any(feature = "core", feature = "send_only"))]
Std(StdRng),
#[cfg(feature = "core")]
Thread(ThreadRng),
#[cfg(feature = "core")]
OS(OsRng),
#[cfg(feature = "custom")]
Custom(CustomRng),
#[cfg(feature = "custom")]
CustomRaw(std::sync::Arc<spin::mutex::Mutex<dyn RngCore>>),
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CustomRawSend(std::sync::Arc<spin::mutex::Mutex<dyn RngCore + Send>>),
#[cfg(feature = "custom")]
CustomCrypto(CustomCryptoRng),
#[cfg(feature = "custom")]
CustomCryptoRaw(std::sync::Arc<spin::mutex::Mutex<dyn RngCrypto>>),
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CustomCryptoRawSend(std::sync::Arc<spin::mutex::Mutex<dyn RngCrypto + Send>>),
}
impl RngCore for RNG {
fn next_u32(&mut self) -> u32 {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
RNG::Std(r) => r.next_u32(),
#[cfg(feature = "core")]
RNG::Thread(r) => r.next_u32(),
#[cfg(feature = "core")]
RNG::OS(r) => r.next_u32(),
#[cfg(feature = "custom")]
RNG::Custom(r) => r.next_u32(),
#[cfg(feature = "custom")]
RNG::CustomRaw(r) => {
let mut rl = r.lock();
rl.next_u32()
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomRawSend(r) => {
let mut rl = r.lock();
rl.next_u32()
},
#[cfg(feature = "custom")]
RNG::CustomCrypto(r) => r.next_u32(),
#[cfg(feature = "custom")]
RNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.next_u32()
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.next_u32()
},
_ => panic!("No known random generator")
}
}
fn next_u64(&mut self) -> u64 {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
RNG::Std(r) => r.next_u64(),
#[cfg(feature = "core")]
RNG::Thread(r) => r.next_u64(),
#[cfg(feature = "core")]
RNG::OS(r) => r.next_u64(),
#[cfg(feature = "custom")]
RNG::Custom(r) => r.next_u64(),
#[cfg(feature = "custom")]
RNG::CustomRaw(r) => {
let mut rl = r.lock();
rl.next_u64()
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomRawSend(r) => {
let mut rl = r.lock();
rl.next_u64()
},
#[cfg(feature = "custom")]
RNG::CustomCrypto(r) => r.next_u64(),
#[cfg(feature = "custom")]
RNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.next_u64()
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.next_u64()
},
_ => panic!("No known random generator")
}
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
RNG::Std(r) => r.fill_bytes(dest),
#[cfg(feature = "core")]
RNG::Thread(r) => r.fill_bytes(dest),
#[cfg(feature = "core")]
RNG::OS(r) => r.fill_bytes(dest),
#[cfg(feature = "custom")]
RNG::Custom(r) => r.fill_bytes(dest),
#[cfg(feature = "custom")]
RNG::CustomRaw(r) => {
let mut rl = r.lock();
rl.fill_bytes(dest)
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomRawSend(r) => {
let mut rl = r.lock();
rl.fill_bytes(dest)
},
#[cfg(feature = "custom")]
RNG::CustomCrypto(r) => r.fill_bytes(dest),
#[cfg(feature = "custom")]
RNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.fill_bytes(dest)
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.fill_bytes(dest)
},
_ => panic!("No known random generator")
}
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
RNG::Std(r) => r.try_fill_bytes(dest),
#[cfg(feature = "core")]
RNG::Thread(r) => r.try_fill_bytes(dest),
#[cfg(feature = "core")]
RNG::OS(r) => r.try_fill_bytes(dest),
#[cfg(feature = "custom")]
RNG::Custom(r) => r.try_fill_bytes(dest),
#[cfg(feature = "custom")]
RNG::CustomRaw(r) => {
let mut rl = r.lock();
rl.try_fill_bytes(dest)
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomRawSend(r) => {
let mut rl = r.lock();
rl.try_fill_bytes(dest)
},
#[cfg(feature = "custom")]
RNG::CustomCrypto(r) => r.try_fill_bytes(dest),
#[cfg(feature = "custom")]
RNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.try_fill_bytes(dest)
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
RNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.try_fill_bytes(dest)
},
_ => panic!("No known random generator")
}
}
}
#[derive(Clone)]
pub enum CryptoRNG {
#[cfg(any(feature = "core", feature = "send_only"))]
Std(StdRng),
#[cfg(feature = "core")]
Thread(ThreadRng),
#[cfg(feature = "core")]
OS(OsRng),
#[cfg(feature = "custom")]
CustomCrypto(CustomCryptoRng),
#[cfg(feature = "custom")]
CustomCryptoRaw(std::sync::Arc<spin::mutex::Mutex<dyn RngCrypto>>),
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CustomCryptoRawSend(std::sync::Arc<spin::mutex::Mutex<dyn RngCrypto + Send>>)
}
impl CryptoRng for CryptoRNG {}
impl RngCore for CryptoRNG {
fn next_u32(&mut self) -> u32 {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
CryptoRNG::Std(r) => r.next_u32(),
#[cfg(feature = "core")]
CryptoRNG::Thread(r) => r.next_u32(),
#[cfg(feature = "core")]
CryptoRNG::OS(r) => r.next_u32(),
#[cfg(feature = "custom")]
CryptoRNG::CustomCrypto(r) => r.next_u32(),
#[cfg(feature = "custom")]
CryptoRNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.next_u32()
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CryptoRNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.next_u32()
},
_ => panic!("No known random generator")
}
}
fn next_u64(&mut self) -> u64 {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
CryptoRNG::Std(r) => r.next_u64(),
#[cfg(feature = "core")]
CryptoRNG::Thread(r) => r.next_u64(),
#[cfg(feature = "core")]
CryptoRNG::OS(r) => r.next_u64(),
#[cfg(feature = "custom")]
CryptoRNG::CustomCrypto(r) => r.next_u64(),
#[cfg(feature = "custom")]
CryptoRNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.next_u64()
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CryptoRNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.next_u64()
},
_ => panic!("No known random generator")
}
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
CryptoRNG::Std(r) => r.fill_bytes(dest),
#[cfg(feature = "core")]
CryptoRNG::Thread(r) => r.fill_bytes(dest),
#[cfg(feature = "core")]
CryptoRNG::OS(r) => r.fill_bytes(dest),
#[cfg(feature = "custom")]
CryptoRNG::CustomCrypto(r) => r.fill_bytes(dest),
#[cfg(feature = "custom")]
CryptoRNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.fill_bytes(dest)
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CryptoRNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.fill_bytes(dest)
},
_ => panic!("No known random generator")
}
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
match self {
#[cfg(any(feature = "core", feature = "send_only"))]
CryptoRNG::Std(r) => r.try_fill_bytes(dest),
#[cfg(feature = "core")]
CryptoRNG::Thread(r) => r.try_fill_bytes(dest),
#[cfg(feature = "core")]
CryptoRNG::OS(r) => r.try_fill_bytes(dest),
#[cfg(feature = "custom")]
CryptoRNG::CustomCrypto(r) => r.try_fill_bytes(dest),
#[cfg(feature = "custom")]
CryptoRNG::CustomCryptoRaw(r) => {
let mut rl = r.lock();
rl.try_fill_bytes(dest)
},
#[cfg(any(feature = "custom", feature = "custom_send_only"))]
CryptoRNG::CustomCryptoRawSend(r) => {
let mut rl = r.lock();
rl.try_fill_bytes(dest)
},
_ => panic!("No known random generator")
}
}
}
#[derive(Clone)]
pub struct RandomGenerator {
generator: RNG
}
#[cfg(any(feature = "constrained", feature = "core", feature = "send_only"))]
impl RandomGenerator {
pub fn new(gen: Option<RNG>) -> Self {
let generator = {
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(g) => g,
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
gen.unwrap_or_else(|| RNG::Std(StdRng::from_entropy()))
}
};
Self {
generator
}
}
pub fn generate_simple_key_one_time(len: usize) -> Vec<u8> {
RandomGenerator::generate_key_one_time(len, &mut None::<RNG>)
}
pub fn generate_key_one_time(len: usize, gen: &mut Option<impl RngCore>) -> Vec<u8> {
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
let mut key = Vec::with_capacity(len);
for _ in 0..len { key.push(rng.gen()); }
key
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
let mut key = Vec::with_capacity(len);
for _ in 0..len { key.push(rng.gen()); }
key
},
None => {
let mut rng = StdRng::from_entropy();
let mut key = Vec::with_capacity(len);
for _ in 0..len { key.push(rng.gen()); }
key
}
}
}
}
pub fn get_simple_random_bytes_one_time(len: usize, gen: &mut Option<impl RngCore>) -> Vec<u8> {
RandomGenerator::get_random_bytes_one_time(len, gen)
}
pub fn get_random_bytes_one_time(len: usize, gen: &mut Option<impl RngCore>) -> Vec<u8> {
let mut bytes = vec![];
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
for _ in 0..len {
let value: u8 = rng.gen_range(0..=255);
bytes.push(value)
}
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
for _ in 0..len {
let value: u8 = rng.gen_range(0..=255);
bytes.push(value)
}
},
None => {
let mut rng = StdRng::from_entropy();
for _ in 0..len {
let value: u8 = rng.gen_range(0..=255);
bytes.push(value)
}
}
}
}
bytes
}
pub fn get_simple_random_usize_one_time(min: usize, max: usize) -> usize {
RandomGenerator::get_random_usize_one_time(min, max, &mut None::<RNG>)
}
pub fn get_random_usize_one_time(min: usize, max: usize, gen: &mut Option<impl RngCore>) -> usize {
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
rng.gen_range(min..=max)
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
rng.gen_range(min..=max)
},
None => {
let mut rng = StdRng::from_entropy();
rng.gen_range(min..=max)
}
}
}
}
pub fn get_simple_random_string_one_time(len: usize, gen: &mut Option<impl RngCore>) -> String {
RandomGenerator::get_random_string_one_time(len, gen)
}
pub fn get_random_string_one_time(len: usize, gen: &mut Option<impl RngCore>) -> String {
let mut str = String::with_capacity(len);
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
for _ in 0..len {
let mut value: u8 = rng.gen_range(33..122);
if value >= 33 && value <= 37 { value = value + 20; }
else if value >= 38 && value <= 47 { value = value + 10; }
else if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
for _ in 0..len {
let mut value: u8 = rng.gen_range(33..122);
if value >= 33 && value <= 37 { value = value + 20; }
else if value >= 38 && value <= 47 { value = value + 10; }
else if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
},
None => {
let mut rng = StdRng::from_entropy();
for _ in 0..len {
let mut value: u8 = rng.gen_range(33..122);
if value >= 33 && value <= 37 { value = value + 20; }
else if value >= 38 && value <= 47 { value = value + 10; }
else if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
}
}
}
str
}
pub fn get_simple_random_from_characters_one_time(len: usize, characters: &str) -> String {
RandomGenerator::get_random_from_characters_one_time(len, characters, &mut None::<RNG>)
}
pub fn get_random_from_characters_one_time(len: usize, characters: &str, gen: &mut Option<impl RngCore>) -> String {
let mut str = String::with_capacity(len);
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
for _ in 0..len {
str.push_str(characters.chars().nth(rng.gen_range(0..characters.len() - 1)).unwrap().to_string().as_str());
}
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
for _ in 0..len {
str.push_str(characters.chars().nth(rng.gen_range(0..characters.len() - 1)).unwrap().to_string().as_str());
}
},
None => {
let mut rng = StdRng::from_entropy();
for _ in 0..len {
str.push_str(characters.chars().nth(rng.gen_range(0..characters.len() - 1)).unwrap().to_string().as_str());
}
}
}
}
str
}
pub fn get_simple_random_alphanumeric_one_time(len: usize) -> String {
RandomGenerator::get_random_alphanumeric_one_time(len, &mut None::<RNG>)
}
pub fn get_random_alphanumeric_one_time(len: usize, gen: &mut Option<impl RngCore>) -> String {
let mut str = String::with_capacity(len);
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
for _ in 0..len {
let mut value: u8 = rng.gen_range(48..122);
if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
for _ in 0..len {
let mut value: u8 = rng.gen_range(48..122);
if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
},
None => {
let mut rng = StdRng::from_entropy();
for _ in 0..len {
let mut value: u8 = rng.gen_range(48..122);
if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
}
}
}
str
}
pub fn get_simple_random_password_one_time(len: usize) -> String {
RandomGenerator::get_random_password_one_time(len, &mut None::<RNG>)
}
pub fn get_random_password_one_time(len: usize, gen: &mut Option<impl RngCore>) -> String {
let mut str = String::with_capacity(len);
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
for _ in 0..len {
let value: u8 = rng.gen_range(33..122);
str.push(char::from(value));
}
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
for _ in 0..len {
let value: u8 = rng.gen_range(33..122);
str.push(char::from(value));
}
},
None => {
let mut rng = StdRng::from_entropy();
for _ in 0..len {
let value: u8 = rng.gen_range(33..122);
str.push(char::from(value));
}
}
}
}
str
}
#[cfg(feature = "names")]
pub fn get_simple_random_email_one_time(num_names: Option<usize>, num_numbers: Option<usize>, separator: Option<String>, domains: Vec<String>) -> String {
RandomGenerator::get_random_email_one_time(num_names, num_numbers, separator, domains, &mut None::<RNG>)
}
#[cfg(feature = "names")]
pub fn get_random_email_one_time(num_names: Option<usize>, num_numbers: Option<usize>, separator: Option<String>, domains: Vec<String>, gen: &mut Option<impl RngCore>) -> String {
let num_names = num_names.unwrap_or_else(|| 2);
let num_numbers = num_numbers.unwrap_or_else(|| 3);
let separator = separator.unwrap_or_else(|| String::from(""));
let mut str = String::new();
let username = RandomGenerator::get_random_username_one_time(Some(num_names), Some(num_numbers), Some(separator.to_owned()), gen);
str.push_str(username.as_str());
str.push_str("@");
let num_domains = domains.len();
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
let pick_domain = rng.gen_range(0..num_domains);
str.push_str(domains.get(pick_domain).unwrap().as_str());
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
let pick_domain = rng.gen_range(0..num_domains);
str.push_str(domains.get(pick_domain).unwrap().as_str());
},
None => {
let mut rng = StdRng::from_entropy();
let pick_domain = rng.gen_range(0..num_domains);
str.push_str(domains.get(pick_domain).unwrap().as_str());
}
}
}
str
}
#[cfg(feature = "names")]
pub fn get_simple_random_username_one_time(num_names: Option<usize>, num_numbers: Option<usize>, separator: Option<String>) -> String {
RandomGenerator::get_random_username_one_time(num_names, num_numbers, separator, &mut None::<RNG>)
}
#[cfg(feature = "names")]
pub fn get_random_username_one_time(num_names: Option<usize>, num_numbers: Option<usize>, separator: Option<String>, gen: &mut Option<impl RngCore>) -> String {
let names_count = names::NAMES.len();
let num_names = num_names.unwrap_or_else(|| 2);
let num_numbers = num_numbers.unwrap_or_else(|| 5);
let separator = separator.unwrap_or_else(|| String::from(""));
let mut str = String::new();
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
for counter in 0..num_names {
let value: usize = rng.gen_range(0..names_count);
if counter > 0 { str.push_str(separator.as_str()); }
str.push_str(names::NAMES[value].to_lowercase().as_str());
}
if num_numbers > 0 { str.push_str(separator.as_str()); }
for _ in 0..num_numbers {
let value: u8 = rng.gen_range(48..57);
str.push(char::from(value));
}
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
for counter in 0..num_names {
let value: usize = rng.gen_range(0..names_count);
if counter > 0 { str.push_str(separator.as_str()); }
str.push_str(names::NAMES[value].to_lowercase().as_str());
}
if num_numbers > 0 { str.push_str(separator.as_str()); }
for _ in 0..num_numbers {
let value: u8 = rng.gen_range(48..57);
str.push(char::from(value));
}
},
None => {
let mut rng = StdRng::from_entropy();
for counter in 0..num_names {
let value: usize = rng.gen_range(0..names_count);
if counter > 0 { str.push_str(separator.as_str()); }
str.push_str(names::NAMES[value].to_lowercase().as_str());
}
if num_numbers > 0 { str.push_str(separator.as_str()); }
for _ in 0..num_numbers {
let value: u8 = rng.gen_range(48..57);
str.push(char::from(value));
}
}
}
}
str
}
#[cfg(feature = "names")]
pub fn get_simple_random_name_one_time() -> String {
RandomGenerator::get_random_name_one_time(&mut None::<RNG>)
}
#[cfg(feature = "names")]
pub fn get_random_name_one_time(gen: &mut Option<impl RngCore>) -> String {
let names_count = names::NAMES.len();
let mut str = String::new();
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
let value: usize = rng.gen_range(0..names_count);
str.push_str(names::NAMES[value]);
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
let value: usize = rng.gen_range(0..names_count);
str.push_str(names::NAMES[value]);
},
None => {
let mut rng = StdRng::from_entropy();
let value: usize = rng.gen_range(0..names_count);
str.push_str(names::NAMES[value]);
}
}
};
str
}
#[cfg(feature = "names")]
pub fn get_simple_random_first_name_one_time() -> String {
RandomGenerator::get_random_first_name_one_time(&mut None::<RNG>)
}
#[cfg(feature = "first_names")]
pub fn get_random_first_name_one_time(gen: &mut Option<impl RngCore>) -> String {
let names_count = first_names::FIRSTNAMES.len();
let mut str = String::new();
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
let value: usize = rng.gen_range(0..names_count);
str.push_str(first_names::FIRSTNAMES[value].to_title_case().as_str());
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
let value: usize = rng.gen_range(0..names_count);
str.push_str(first_names::FIRSTNAMES[value].to_title_case().as_str());
},
None => {
let mut rng = StdRng::from_entropy();
let value: usize = rng.gen_range(0..names_count);
str.push_str(first_names::FIRSTNAMES[value].to_title_case().as_str());
}
}
}
str
}
#[cfg(feature = "names")]
pub fn get_simple_random_last_name_one_time() -> String {
RandomGenerator::get_random_last_name_one_time(&mut None::<RNG>)
}
#[cfg(feature = "last_names")]
pub fn get_random_last_name_one_time(gen: &mut Option<impl RngCore>) -> String {
let names_count = last_names::LASTNAMES.len();
let mut str = String::new();
#[cfg(all(feature = "constrained", all(not(feature = "core"), not(feature = "send_only"))))] {
match gen {
Some(rng) => {
let value: usize = rng.gen_range(0..names_count);
str.push_str(last_names::LASTNAMES[value].to_title_case().as_str());
},
None => panic!("No generator provided")
}
}
#[cfg(any(feature = "core", feature = "send_only"))] {
match gen {
Some(rng) => {
let value: usize = rng.gen_range(0..names_count);
str.push_str(last_names::LASTNAMES[value].to_title_case().as_str());
},
None => {
let mut rng = StdRng::from_entropy();
let value: usize = rng.gen_range(0..names_count);
str.push_str(last_names::LASTNAMES[value].to_title_case().as_str());
}
}
}
str
}
}
impl RandomGeneratorTemplate for RandomGenerator {
fn get_random_bytes(&mut self, len: usize) -> Vec<u8> {
let mut bytes = vec![];
for _ in 0..len {
let value: u8 = self.generator.gen_range(0..=255);
bytes.push(value)
}
bytes
}
fn get_random_usize(&mut self, min: usize, max: usize) -> usize {
self.generator.gen_range(min..=max)
}
fn get_random_u32(&mut self) -> u32 {
self.generator.next_u32()
}
fn get_random_u64(&mut self) -> u64 {
self.generator.next_u64()
}
fn get_random_string(&mut self, len: usize) -> String {
let mut str = String::with_capacity(len);
for _ in 0..len {
let mut value: u8 = self.generator.gen_range(33..122);
if value >= 33 && value <= 37 { value = value + 20; }
else if value >= 38 && value <= 47 { value = value + 10; }
else if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
str
}
fn get_random_from_characters(&mut self, len: usize, characters: &str) -> String {
let mut str = String::with_capacity(len);
for _ in 0..len {
str.push_str(characters.chars().nth(self.generator.gen_range(0..characters.len() - 1)).unwrap().to_string().as_str());
}
str
}
fn get_random_alphanumeric(&mut self, len: usize) -> String {
let mut str = String::with_capacity(len);
for _ in 0..len {
let mut value: u8 = self.generator.gen_range(48..122);
if value >= 58 && value <= 64 { value = value + 10; }
else if value >= 91 && value <= 96 { value = value + 10; }
str.push(char::from(value));
}
str
}
fn generate_key(&mut self, len: usize) -> Vec<u8> {
let mut key = Vec::with_capacity(len);
for _ in 0..len { key.push(self.generator.gen()); }
key
}
}
pub trait RandomGeneratorTemplate {
fn get_random_bytes(&mut self, len: usize) -> Vec<u8>;
fn get_random_usize(&mut self, min: usize, max: usize) -> usize;
fn get_random_u32(&mut self) -> u32;
fn get_random_u64(&mut self) -> u64;
fn get_random_string(&mut self, len: usize) -> String;
fn get_random_from_characters(&mut self, len: usize, characters: &str) -> String;
fn get_random_alphanumeric(&mut self, len: usize) -> String;
fn generate_key(&mut self, len: usize) -> Vec<u8>;
}