pub enum Generator {
Show 15 variants
AlphaLower,
AlphaUpper,
Digit,
AlphaNumLower,
AlphaNumUpper,
HexUpper,
HexLower,
Char(char),
Str(String),
OneOf {
v: Vec<Generator>,
is_optional: bool,
},
RepeatedN(Box<Generator>, usize),
RepeatedMN(Box<Generator>, usize, usize),
Sequence(Vec<Generator>),
Transform {
inner: Box<Generator>,
transform_fn: TransformFn,
},
Empty,
}
Expand description
The building block of generator-combinators.
A Generator
can be constructed from strings, chars, and slices:
use generator_combinator::Generator;
let foo = Generator::from("foo"); // generates the string `foo`
let dot = Generator::from('.'); // generates the string `.`
let countries = Generator::from(&["US", "FR", "NZ", "CH"][..]); // generates strings `US`, `FR`, `NZ`, and `CH`.
Individual Generator
s can be combined as sequences with +
, as variants with |
, and with repetition with * usize
and * (usize, usize)
:
use generator_combinator::Generator;
let foo = Generator::from("foo");
let bar = Generator::from("bar");
let foobar = foo.clone() + bar.clone(); // generates `foobar`
let foo_or_bar = foo.clone() | bar.clone(); // generates `foo`, `bar`
let foo_or_bar_x2 = foo_or_bar.clone() * 2; // generates `foofoo`, `foobar`, `barfoo`, `barbar`
let foo_x2_to_x4 = foo.clone() * (2, 4); // generates `foofoo`, `foofoofoo`, `foofoofoofoo`
Variants§
AlphaLower
Lowercase ASCII letters (a-z)
AlphaUpper
Uppercase ASCII letters (A-Z)
Digit
Base-10 digits (0-9)
AlphaNumLower
Lowercase ASCII letters and digits (a-z0-9)
AlphaNumUpper
Uppercase ASCII letters and digits (A-Z0-9)
HexUpper
Uppercase hexadecimal values (0-9A-F)
HexLower
Lowercase hexadecimal values (0-9a-f)
Char(char)
Generates a char
literal.
Str(String)
Generates a String
literal.
Note that this is not a character class.
Str("foo".into())
generates the exact string "foo"
OneOf
A choice between two or more patterns
As a regex, this would be, eg, (a|b|c)?
(depending on is_optional
)
RepeatedN(Box<Generator>, usize)
A pattern repeated exactly n times. This is the same as RepeatedMN
(a, n, n)
As a regex, this would be a{n}
RepeatedMN(Box<Generator>, usize, usize)
A pattern repeated at least m times, as many as n times.
As a regex, this would be a{m,n}
Sequence(Vec<Generator>)
Two or more sequential patterns.
As a regex, this would be, eg, abc
Transform
Wrap the current generator in a user-defined transformation.
Empty
Doesn’t generate anything
Implementations§
Source§impl Generator
impl Generator
Sourcepub fn regex(&self) -> String
pub fn regex(&self) -> String
Create a regular expression that represents the patterns generated.
The result here is currently best-guess. It’s not guaranteed valid, correct, idiomatic, etc.
Sourcepub fn generate_one(&self, num: u128) -> String
pub fn generate_one(&self, num: u128) -> String
Generates the String
encoded by the specified num
.
Panics if num
exceeds the length given by Generator::len
Sourcepub fn optional(self) -> Self
pub fn optional(self) -> Self
Makes this Generator
optional.
As a regex, this is the ?
operator.
Sourcepub fn generate_all(&self) -> StringIter<'_> ⓘ
pub fn generate_all(&self) -> StringIter<'_> ⓘ
Provides an iterator across all possible values for this Generator
.
Sourcepub fn transform(self, f: fn(String) -> String) -> Self
pub fn transform(self, f: fn(String) -> String) -> Self
Includes a user-defined transformation when generating values.
Sourcepub fn visit_one<F>(&self, num: u128, cb: F)
pub fn visit_one<F>(&self, num: u128, cb: F)
For a value specified by num
, applies the callback cb
for each of the component values
for this Generator.
This may be preferable to [generate_one
] if you want to see the individual components
comprising the final string and/or if you want to avoid the memory allocation and freeing
by creating the values.
Trait Implementations§
Source§impl Add for Generator
Add operator for exact repetitions.
impl Add for Generator
Add operator for exact repetitions.
The following expressions are equivalent:
use generator_combinator::Generator;
let foostr = Generator::from("foofoo");
let foomul = Generator::from("foo") * 2;
let fooadd = Generator::from("foo") + Generator::from("foo");
Source§impl AddAssign<&str> for Generator
impl AddAssign<&str> for Generator
Source§fn add_assign(&mut self, rhs: &str)
fn add_assign(&mut self, rhs: &str)
+=
operation. Read moreSource§impl AddAssign<String> for Generator
impl AddAssign<String> for Generator
Source§fn add_assign(&mut self, rhs: String)
fn add_assign(&mut self, rhs: String)
+=
operation. Read moreSource§impl AddAssign<char> for Generator
impl AddAssign<char> for Generator
Source§fn add_assign(&mut self, rhs: char)
fn add_assign(&mut self, rhs: char)
+=
operation. Read moreSource§impl AddAssign for Generator
impl AddAssign for Generator
Source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
+=
operation. Read moreSource§impl BitOrAssign<&str> for Generator
impl BitOrAssign<&str> for Generator
Source§fn bitor_assign(&mut self, rhs: &str)
fn bitor_assign(&mut self, rhs: &str)
|=
operation. Read moreSource§impl BitOrAssign<String> for Generator
impl BitOrAssign<String> for Generator
Source§fn bitor_assign(&mut self, rhs: String)
fn bitor_assign(&mut self, rhs: String)
|=
operation. Read moreSource§impl BitOrAssign<char> for Generator
impl BitOrAssign<char> for Generator
Source§fn bitor_assign(&mut self, rhs: char)
fn bitor_assign(&mut self, rhs: char)
|=
operation. Read moreSource§impl BitOrAssign for Generator
impl BitOrAssign for Generator
Source§fn bitor_assign(&mut self, rhs: Self)
fn bitor_assign(&mut self, rhs: Self)
|=
operation. Read moreSource§impl<'a> From<&'a Generator> for StringIter<'a>
impl<'a> From<&'a Generator> for StringIter<'a>
Source§impl Mul<(usize, usize)> for Generator
Mul operator for repetitions between m
and n
(inclusive)
impl Mul<(usize, usize)> for Generator
Mul operator for repetitions between m
and n
(inclusive)
use generator_combinator::Generator;
let foo_two_to_five_times = Generator::from("foo") * (2,5);
Source§impl Mul<usize> for Generator
Mul operator for exact repetitions.
impl Mul<usize> for Generator
Mul operator for exact repetitions.
The following expressions are equivalent:
use generator_combinator::Generator;
let foostr = Generator::from("foofoo");
let foomul = Generator::from("foo") * 2;
let fooadd = Generator::from("foo") + Generator::from("foo");
Source§impl MulAssign<usize> for Generator
impl MulAssign<usize> for Generator
Source§fn mul_assign(&mut self, rhs: usize)
fn mul_assign(&mut self, rhs: usize)
*=
operation. Read more