Class in regex_syntax::hir - Rust (original) (raw)

pub enum Class {
    Unicode(ClassUnicode),
    Bytes(ClassBytes),
}

Expand description

The high-level intermediate representation of a character class.

A character class corresponds to a set of characters. A character is either defined by a Unicode scalar value or a byte.

A character class, regardless of its character type, is represented by a sequence of non-overlapping non-adjacent ranges of characters.

There are no guarantees about which class variant is used. Generally speaking, the Unicode variat is used whenever a class needs to contain non-ASCII Unicode scalar values. But the Unicode variant can be used even when Unicode mode is disabled. For example, at the time of writing, the regex (?-u:a|\xc2\xa0) will compile down to HIR for the Unicode class[a\u00A0] due to optimizations.

Note that Bytes variant may be produced even when it exclusively matches valid UTF-8. This is because a Bytes variant represents an intention by the author of the regular expression to disable Unicode mode, which in turn impacts the semantics of case insensitive matching. For example, (?i)kand (?i-u)k will not match the same set of strings.

A set of characters represented by Unicode scalar values.

A set of characters represented by arbitrary bytes (one byte per character).

Source §

Source

Apply Unicode simple case folding to this character class, in place. The character class will be expanded to include all simple case folded character variants.

If this is a byte oriented character class, then this will be limited to the ASCII ranges A-Z and a-z.

§Panics

This routine panics when the case mapping data necessary for this routine to complete is unavailable. This occurs when the unicode-casefeature is not enabled and the underlying class is Unicode oriented.

Callers should prefer using try_case_fold_simple instead, which will return an error instead of panicking.

Source

Apply Unicode simple case folding to this character class, in place. The character class will be expanded to include all simple case folded character variants.

If this is a byte oriented character class, then this will be limited to the ASCII ranges A-Z and a-z.

§Error

This routine returns an error when the case mapping data necessary for this routine to complete is unavailable. This occurs when theunicode-case feature is not enabled and the underlying class is Unicode oriented.

Source

Negate this character class in place.

After completion, this character class will contain precisely the characters that weren’t previously in the class.

Source

Returns true if and only if this character class will only ever match valid UTF-8.

A character class can match invalid UTF-8 only when the following conditions are met:

The translator was configured to permit generating an expression that can match invalid UTF-8. (By default, this is disabled.)
Unicode mode (via the u flag) was disabled either in the concrete syntax or in the parser builder. By default, Unicode mode is enabled.

Source

Returns the length, in bytes, of the smallest string matched by this character class.

For non-empty byte oriented classes, this always returns 1. For non-empty Unicode oriented classes, this can return 1, 2, 3 or4. For empty classes, None is returned. It is impossible for 0 to be returned.

§Example

This example shows some examples of regexes and their corresponding minimum length, if any.

use regex_syntax::{hir::Properties, parse};

// The empty string has a min length of 0.
let hir = parse(r"")?;
assert_eq!(Some(0), hir.properties().minimum_len());
// As do other types of regexes that only match the empty string.
let hir = parse(r"^$\b\B")?;
assert_eq!(Some(0), hir.properties().minimum_len());
// A regex that can match the empty string but match more is still 0.
let hir = parse(r"a*")?;
assert_eq!(Some(0), hir.properties().minimum_len());
// A regex that matches nothing has no minimum defined.
let hir = parse(r"[a&&b]")?;
assert_eq!(None, hir.properties().minimum_len());
// Character classes usually have a minimum length of 1.
let hir = parse(r"\w")?;
assert_eq!(Some(1), hir.properties().minimum_len());
// But sometimes Unicode classes might be bigger!
let hir = parse(r"\p{Cyrillic}")?;
assert_eq!(Some(2), hir.properties().minimum_len());

Source

Returns the length, in bytes, of the longest string matched by this character class.

§Example

This example shows some examples of regexes and their corresponding maximum length, if any.

use regex_syntax::{hir::Properties, parse};

// The empty string has a max length of 0.
let hir = parse(r"")?;
assert_eq!(Some(0), hir.properties().maximum_len());
// As do other types of regexes that only match the empty string.
let hir = parse(r"^$\b\B")?;
assert_eq!(Some(0), hir.properties().maximum_len());
// A regex that matches nothing has no maximum defined.
let hir = parse(r"[a&&b]")?;
assert_eq!(None, hir.properties().maximum_len());
// Bounded repeats work as you expect.
let hir = parse(r"x{2,10}")?;
assert_eq!(Some(10), hir.properties().maximum_len());
// An unbounded repeat means there is no maximum.
let hir = parse(r"x{2,}")?;
assert_eq!(None, hir.properties().maximum_len());
// With Unicode enabled, \w can match up to 4 bytes!
let hir = parse(r"\w")?;
assert_eq!(Some(4), hir.properties().maximum_len());
// Without Unicode enabled, \w matches at most 1 byte.
let hir = parse(r"(?-u)\w")?;
assert_eq!(Some(1), hir.properties().maximum_len());

Source

Returns true if and only if this character class is empty. That is, it has no elements.

An empty character can never match anything, including an empty string.

Source

If this class consists of exactly one element (whether a codepoint or a byte), then return it as a literal byte string.

If this class is empty or contains more than one element, then Noneis returned.

Source §

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source §

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Source §