Enum RegexCount 

pub enum RegexCount {
    Default,
    Bytes(NonZeroU32),
    Lines(Option<NonZeroU32>),
}

Scan window specifier for a TypeKind::Regex rule.

Encodes the three mutually-exclusive scan modes in a single enum so that the “byte count” and “line count” cases cannot be confused. The regex/l shorthand (line mode with no explicit count) is represented explicitly as RegexCount::Lines(None), which is behaviorally equivalent to RegexCount::Default – both walk the full 8192-byte capped window – but preserves the magic-file surface syntax of the original rule. The 8192-byte hard cap (matching GNU file’s FILE_REGEX_MAX) is applied by the evaluator on every variant.

Examples

use libmagic_rs::parser::ast::RegexCount;
use std::num::NonZeroU32;

// Plain `regex` (no suffix): default 8192-byte window.
assert_eq!(RegexCount::default(), RegexCount::Default);

// `regex/100`: scan at most 100 bytes.
let hundred_bytes = RegexCount::Bytes(NonZeroU32::new(100).unwrap());

// `regex/1l`: scan the first line.
let one_line = RegexCount::Lines(NonZeroU32::new(1));

// `regex/l`: line-mode with no explicit count (walks terminators
// to the end of the 8192-byte capped window).
let unbounded_lines = RegexCount::Lines(None);

Variants

Default

No scan bound (plain regex with no suffix). Scans the default 8192-byte window from the rule’s offset.

Bytes(NonZeroU32)

Byte-bounded scan (regex/N with no /l flag). The window is min(n, 8192, remaining_buffer) bytes long. NonZeroU32 makes a zero-byte scan unrepresentable.

Lines(Option<NonZeroU32>)

Line-bounded scan (regex/Nl or regex/l). The window walks LF / CRLF / bare CR line terminators from the offset. With Some(n), the walk stops after the Nth terminator (inclusive). With None (the regex/l shorthand), the walk continues to the end of the 8192-byte capped window. Either way the effective byte window is capped at 8192.

Trait Implementations

impl Clone for RegexCount

fn clone(&self) -> RegexCount

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RegexCount

impl Debug for RegexCount

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RegexCount

fn default() -> RegexCount

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RegexCount

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RegexCount

impl PartialEq for RegexCount

fn eq(&self, other: &RegexCount) -> bool

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

fn ne(&self, other: &Rhs) -> bool

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

impl Serialize for RegexCount

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RegexCount