# [−] [src] Struct regex_syntax::hir::literal::Literals

    pub struct Literals { /* fields omitted */ }

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.

## Methods

### `impl Literals` [src]

#### `pub fn empty() -> Literals` [src]

Returns a new empty set of literals using default limits.

#### `pub fn prefixes(expr: &Hir) -> Literals` [src]

Returns a set of literal prefixes extracted from the given `Hir`.

#### `pub fn suffixes(expr: &Hir) -> Literals` [src]

Returns a set of literal suffixes extracted from the given `Hir`.

#### `pub fn limit_size(&self) -> usize` [src]

Get the approximate size limit (in bytes) of this set.

#### `pub fn set_limit_size(&mut self, size: usize) -> &mut Literals` [src]

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.

#### `pub fn limit_class(&self) -> usize` [src]

Get the character class size limit for this set.

#### `pub fn set_limit_class(&mut self, size: usize) -> &mut Literals` [src]

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.

#### `pub fn literals(&self) -> &[Literal]` [src]

Returns the set of literals as a slice. Its order is unspecified.

#### `pub fn min_len(&self) -> Option<usize>` [src]

Returns the length of the smallest literal.

Returns None is there are no literals in the set.

#### `pub fn all_complete(&self) -> bool` [src]

Returns true if all members in this set are complete.

#### `pub fn any_complete(&self) -> bool` [src]

Returns true if any member in this set is complete.

#### `pub fn contains_empty(&self) -> bool` [src]

Returns true if this set contains an empty literal.

#### `pub fn is_empty(&self) -> bool` [src]

Returns true if this set is empty or if all of its members is empty.

#### `pub fn to_empty(&self) -> Literals` [src]

Returns a new empty set of literals using this set's limits.

#### `pub fn longest_common_prefix(&self) -> &[u8]` [src]

Returns the longest common prefix of all members in this set.

#### `pub fn longest_common_suffix(&self) -> &[u8]` [src]

Returns the longest common suffix of all members in this set.

#### `pub fn trim_suffix(&self, num_bytes: usize) -> Option<Literals>` [src]

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.

#### `pub fn unambiguous_prefixes(&self) -> Literals` [src]

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.

#### `pub fn unambiguous_suffixes(&self) -> Literals` [src]

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.

#### `pub fn union_prefixes(&mut self, expr: &Hir) -> bool` [src]

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`.

#### `pub fn union_suffixes(&mut self, expr: &Hir) -> bool` [src]

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`.

#### `pub fn union(&mut self, lits: Literals) -> bool` [src]

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.

#### `pub fn cross_product(&mut self, lits: &Literals) -> bool` [src]

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.

#### `pub fn cross_add(&mut self, bytes: &[u8]) -> bool` [src]

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.

#### `pub fn add(&mut self, lit: Literal) -> bool` [src]

Adds the given literal to this set.

Returns false if adding this literal would cause the class to be too big.

#### `pub fn add_char_class(&mut self, cls: &ClassUnicode) -> bool` [src]

Extends each literal in this set with the character class given.

Returns false if the character class was too big to add.

#### `pub fn add_byte_class(&mut self, cls: &ClassBytes) -> bool` [src]

Extends each literal in this set with the byte class given.

Returns false if the byte class was too big to add.

#### `pub fn cut(&mut self)` [src]

Cuts every member of this set. When a member is cut, it can never be extended.

#### `pub fn reverse(&mut self)` [src]

Reverses all members in place.

#### `pub fn clear(&mut self)` [src]

Clears this set of all members.

## Trait Implementations

### `impl PartialEq<Literals> for Literals` [src]

#### `fn eq(&self, other: &Literals) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Literals) -> bool` [src]

This method tests for `!=`.

### `impl Clone for Literals` [src]

#### `fn clone(&self) -> Literals` [src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Eq for Literals` [src]

### `impl Debug for Literals` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl Send for Literals`

### `impl Sync for Literals`

## Blanket Implementations

### `impl<T> From<T> for T` [src]

#### `fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)