Struct RepeatTool

pub struct RepeatTool<T, SEP> { /* private fields */ }

Tool that matches repetitions with separator requiring a minimum number of repetitions.

let lt = minparser::view::ViewFile::new_default("a a a a b");
assert_eq!(lt.match_tool_string(minparser::tools::RepeatTool::new_sep_bounds('a', ' ', 0, 3))
.unwrap().1, "a a a");
assert_eq!(lt.match_tool_string(minparser::tools::RepeatTool::new_sep_bounds('a', ' ', 2, 3))
.unwrap().1, "a a a");
assert_eq!(lt.match_tool_string(minparser::tools::RepeatTool::new_sep_unbounded('a', ' ', 0))
.unwrap().1, "a a a a");
assert_eq!(lt.match_tool_string(minparser::tools::RepeatTool::new_sep_unbounded('a', ' ', 2))
.unwrap().1, "a a a a");
assert!(lt.match_tool_string(minparser::tools::RepeatTool::new_sep_unbounded('a', ' ', 5))
.is_err());
assert!(lt.match_tool_string(minparser::tools::RepeatTool::new_sep_bounds('a', ' ', 2, 1))
.is_err());

Implementations

impl<T, SEP> RepeatTool<T, SEP>

pub const fn new_sep(tool: T, sep: SEP, min: usize, max: Option<usize>) -> Self

Create a new RepeatTool with specified separator.

pub const fn new_sep_bounds(tool: T, sep: SEP, min: usize, max: usize) -> Self

Create a new RepeatTool with specified separator and upper bound

pub const fn new_sep_unbounded(tool: T, sep: SEP, min: usize) -> Self

Create a new RepeatTool with specified separator without upper bound

pub const fn new_any_one(tool: T, sep: SEP) -> Self

Create a new RepeatTool that matches at least one occurrence

impl<T> RepeatTool<T, TrueParser>

pub const fn new(tool: T, min: usize, max: Option<usize>) -> Self

Create a new RepeatTool without spaces.

Panics

Panic if max is strictly lesser than min.

pub const fn new_bounds(tool: T, min: usize, max: usize) -> Self

Create a new RepeatTool with specified upper bound

pub const fn new_unbounded(tool: T, min: usize) -> Self

Create a new RepeatTool without upper bound

Trait Implementations

impl<T: Clone, SEP: Clone> Clone for RepeatTool<T, SEP>

fn clone(&self) -> RepeatTool<T, SEP>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, SEP: Debug> Debug for RepeatTool<T, SEP>

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

Formats the value using the given formatter.

impl<T, SEP> ParseTool for RepeatTool<T, SEP>

where T: ParseTool, SEP: ParseTool,

fn parse(&self, st: &str) -> ToolResult

The main parsing algorithm.

fn as_dyn(&self) -> &dyn ParseTool

where Self: Sized,

Coerce to dyn trait

impl<T: Copy, SEP: Copy> Copy for RepeatTool<T, SEP>