Struct regex_syntax::hir::literal::Literals
source · pub struct Literals { /* private fields */ }Expand description
A set of literal byte strings extracted from a regular expression.
Every member of the set is a Literal, which is represented by a
Vec<u8>. (Notably, it may contain invalid UTF-8.) Every member is
said to be either complete or cut. A complete literal means that
it extends until the beginning (or end) of the regular expression. In
some circumstances, this can be used to indicate a match in the regular
expression.
A key aspect of literal extraction is knowing when to stop. It is not
feasible to blindly extract all literals from a regular expression, even if
there are finitely many. For example, the regular expression [0-9]{10}
has 10^10 distinct literals. For this reason, literal extraction is
bounded to some low number by default using heuristics, but the limits can
be tweaked.
WARNING: Literal extraction uses stack space proportional to the size
of the Hir expression. At some point, this drawback will be eliminated.
To protect yourself, set a reasonable
nest_limit on your Parser.
This is done for you by default.
Implementations§
source§impl Literals
impl Literals
sourcepub fn prefixes(expr: &Hir) -> Literals
pub fn prefixes(expr: &Hir) -> Literals
Returns a set of literal prefixes extracted from the given Hir.
sourcepub fn suffixes(expr: &Hir) -> Literals
pub fn suffixes(expr: &Hir) -> Literals
Returns a set of literal suffixes extracted from the given Hir.
sourcepub fn limit_size(&self) -> usize
pub fn limit_size(&self) -> usize
Get the approximate size limit (in bytes) of this set.
sourcepub fn set_limit_size(&mut self, size: usize) -> &mut Literals
pub fn set_limit_size(&mut self, size: usize) -> &mut Literals
Set the approximate size limit (in bytes) of this set.
If extracting a literal would put the set over this limit, then extraction stops.
The new limits will only apply to additions to this set. Existing members remain unchanged, even if the set exceeds the new limit.
sourcepub fn limit_class(&self) -> usize
pub fn limit_class(&self) -> usize
Get the character class size limit for this set.
sourcepub fn set_limit_class(&mut self, size: usize) -> &mut Literals
pub fn set_limit_class(&mut self, size: usize) -> &mut Literals
Limits the size of character(or byte) classes considered.
A value of 0 prevents all character classes from being considered.
This limit also applies to case insensitive literals, since each character in the case insensitive literal is converted to a class, and then case folded.
The new limits will only apply to additions to this set. Existing members remain unchanged, even if the set exceeds the new limit.
sourcepub fn literals(&self) -> &[Literal]
pub fn literals(&self) -> &[Literal]
Returns the set of literals as a slice. Its order is unspecified.
sourcepub fn min_len(&self) -> Option<usize>
pub fn min_len(&self) -> Option<usize>
Returns the length of the smallest literal.
Returns None is there are no literals in the set.
sourcepub fn all_complete(&self) -> bool
pub fn all_complete(&self) -> bool
Returns true if all members in this set are complete.
sourcepub fn any_complete(&self) -> bool
pub fn any_complete(&self) -> bool
Returns true if any member in this set is complete.
sourcepub fn contains_empty(&self) -> bool
pub fn contains_empty(&self) -> bool
Returns true if this set contains an empty literal.
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true if this set is empty or if all of its members is empty.
sourcepub fn to_empty(&self) -> Literals
pub fn to_empty(&self) -> Literals
Returns a new empty set of literals using this set’s limits.
sourcepub fn longest_common_prefix(&self) -> &[u8] ⓘ
pub fn longest_common_prefix(&self) -> &[u8] ⓘ
Returns the longest common prefix of all members in this set.
sourcepub fn longest_common_suffix(&self) -> &[u8] ⓘ
pub fn longest_common_suffix(&self) -> &[u8] ⓘ
Returns the longest common suffix of all members in this set.
sourcepub fn trim_suffix(&self, num_bytes: usize) -> Option<Literals>
pub fn trim_suffix(&self, num_bytes: usize) -> Option<Literals>
Returns a new set of literals with the given number of bytes trimmed from the suffix of each literal.
If any literal would be cut out completely by trimming, then None is returned.
Any duplicates that are created as a result of this transformation are removed.
sourcepub fn unambiguous_prefixes(&self) -> Literals
pub fn unambiguous_prefixes(&self) -> Literals
Returns a new set of prefixes of this set of literals that are guaranteed to be unambiguous.
Any substring match with a member of the set is returned is guaranteed to never overlap with a substring match of another member of the set at the same starting position.
Given any two members of the returned set, neither is a substring of the other.
sourcepub fn unambiguous_suffixes(&self) -> Literals
pub fn unambiguous_suffixes(&self) -> Literals
Returns a new set of suffixes of this set of literals that are guaranteed to be unambiguous.
Any substring match with a member of the set is returned is guaranteed to never overlap with a substring match of another member of the set at the same ending position.
Given any two members of the returned set, neither is a substring of the other.
sourcepub fn union_prefixes(&mut self, expr: &Hir) -> bool
pub fn union_prefixes(&mut self, expr: &Hir) -> bool
Unions the prefixes from the given expression to this set.
If prefixes could not be added (for example, this set would exceed its
size limits or the set of prefixes from expr includes the empty
string), then false is returned.
Note that prefix literals extracted from expr are said to be complete
if and only if the literal extends from the beginning of expr to the
end of expr.
sourcepub fn union_suffixes(&mut self, expr: &Hir) -> bool
pub fn union_suffixes(&mut self, expr: &Hir) -> bool
Unions the suffixes from the given expression to this set.
If suffixes could not be added (for example, this set would exceed its
size limits or the set of suffixes from expr includes the empty
string), then false is returned.
Note that prefix literals extracted from expr are said to be complete
if and only if the literal extends from the end of expr to the
beginning of expr.
sourcepub fn union(&mut self, lits: Literals) -> bool
pub fn union(&mut self, lits: Literals) -> bool
Unions this set with another set.
If the union would cause the set to exceed its limits, then the union is skipped and it returns false. Otherwise, if the union succeeds, it returns true.
sourcepub fn cross_product(&mut self, lits: &Literals) -> bool
pub fn cross_product(&mut self, lits: &Literals) -> bool
Extends this set with another set.
The set of literals is extended via a cross product.
If a cross product would cause this set to exceed its limits, then the cross product is skipped and it returns false. Otherwise, if the cross product succeeds, it returns true.
sourcepub fn cross_add(&mut self, bytes: &[u8]) -> bool
pub fn cross_add(&mut self, bytes: &[u8]) -> bool
Extends each literal in this set with the bytes given.
If the set is empty, then the given literal is added to the set.
If adding any number of bytes to all members of this set causes a limit
to be exceeded, then no bytes are added and false is returned. If a
prefix of bytes can be fit into this set, then it is used and all
resulting literals are cut.
sourcepub fn add(&mut self, lit: Literal) -> bool
pub fn add(&mut self, lit: Literal) -> bool
Adds the given literal to this set.
Returns false if adding this literal would cause the class to be too big.
sourcepub fn add_char_class(&mut self, cls: &ClassUnicode) -> bool
pub fn add_char_class(&mut self, cls: &ClassUnicode) -> bool
Extends each literal in this set with the character class given.
Returns false if the character class was too big to add.
sourcepub fn add_byte_class(&mut self, cls: &ClassBytes) -> bool
pub fn add_byte_class(&mut self, cls: &ClassBytes) -> bool
Extends each literal in this set with the byte class given.
Returns false if the byte class was too big to add.