Struct RegexInput 

pub struct RegexInput<'h, S: Input + ?Sized> { /* private fields */ }

A search configuration for matching against a haystack.

This keeps the original haystack together with a starting search position and a range that constrains where the overall match may occur. Unlike slicing a haystack, anchors and lookaround can still inspect the full original input, and reported offsets remain absolute.

Implementations

impl<'h, S: Input + ?Sized> RegexInput<'h, S>

pub fn new(haystack: &'h S) -> Self

Create a new search input over the full haystack.

pub fn haystack(&self) -> &'h S

Return the haystack being searched.

pub fn start(&self) -> usize

Return the requested starting position for this search.

pub fn get_range(&self) -> Range<usize>

Return the range constraining where match 0 may occur.

pub fn from_pos(self, start: usize) -> Self

Return a copy of this input with a different search start.

pub fn range(self, range: Range<usize>) -> Self

Return a copy of this input with a different search range.

Panics

Panics if the range is not within the haystack bounds or if range.start > range.end.

pub fn start_text(self, yes: bool) -> Self

Return a copy of this input with an override for whether ^/\A should match.

This override is suppression-only: false suppresses the assertion, while true clears the override and preserves default behavior.

pub fn end_text(self, yes: bool) -> Self

Return a copy of this input with an override for whether $/\z should match.

This override is suppression-only: false suppresses the assertion, while true clears the override and preserves default behavior.

pub fn continue_from_previous_match_end(self, yes: bool) -> Self

Return a copy of this input with an override for whether \G should match.

This override is suppression-only: false suppresses the assertion, while true clears the override and preserves default behavior.

pub fn anchored(self, yes: bool) -> Self

Return a copy of this input with an override for whether matching should be anchored at the start position.

When true, the regex will only match at the exact start position, without scanning forward through the haystack. This is more efficient when you already know where a potential match must occur.

Trait Implementations

impl<'h, S: Input + ?Sized> Clone for RegexInput<'h, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'h, S: Debug + Input + ?Sized> Debug for RegexInput<'h, S>

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

Formats the value using the given formatter.

impl<'h, S: Input + ?Sized> From<&'h S> for RegexInput<'h, S>

fn from(haystack: &'h S) -> Self

Converts to this type from the input type.