Struct ParseContainer

pub struct ParseContainer { /* private fields */ }

An intermediate representation to parse.

The ParseContainer has a shared pointer of the original String and the pair of sub-string position (begin and end),

Implementations

impl ParseContainer

pub fn new(raw: Arc<String>) -> Self

Creates a new ParseContainer from the original string. The inner positions are held in the entirety of the original string.

Examples

let _ = ParseContainer::new(Arc::new("foo".to_string()));

pub fn is_empty(&self) -> bool

Returns true if self has a length of zero

Examples

let container = ParseContainer::from("");
assert!(container.is_empty());

let container = ParseContainer::from("foo");
let (_rest, parsed) = container.split_at(0);
assert!(parsed.is_empty());
let (rest, _parsed) = container.split_at(container.len());
assert!(rest.is_empty());

pub fn len(&self) -> usize

Returns the length of self

Examples

let container = ParseContainer::from("foo");
assert_eq!(container.len(), 3);

pub fn as_str(&self) -> &str

Returns a string slice of the sub-string

Examples

let container = ParseContainer::from("foo");
let s: &str = container.as_str(); // Returns `&str`
assert_eq!(s, "foo");

pub fn split_at(&self, mid: usize) -> (Self, Self)

Splits into two sub-strings by mid

• mid - A position to split.

Panics

Panics if mid is past the end of the sub-string.

Examples

let container = ParseContainer::from("Hello, World!");
let (rest, parsed) = container.split_at(7);
assert_eq!(rest, "World!");
assert_eq!(parsed, "Hello, ");

let (rest, parsed) = container.split_at(0);
assert_eq!(rest, "Hello, World!");
assert_eq!(parsed, "");

let (rest, parsed) = container.split_at(container.len());
assert_eq!(rest, "");
assert_eq!(parsed, "Hello, World!");

Trait Implementations

impl Borrow<str> for ParseContainer

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Clone for ParseContainer

fn clone(&self) -> ParseContainer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ParseContainer

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

Formats the value using the given formatter.

impl Display for ParseContainer

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

Formats the value using the given formatter.

impl From<&[ParseContainer]> for ParseContainer

fn from(x: &[ParseContainer]) -> Self

Converts to this type from the input type.

impl<const N: usize> From<&[ParseContainer; N]> for ParseContainer

fn from(x: &[ParseContainer; N]) -> Self

Converts to this type from the input type.

impl From<&str> for ParseContainer

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<String> for ParseContainer

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<Vec<ParseContainer>> for ParseContainer

fn from(x: Vec<ParseContainer>) -> Self

Converts to this type from the input type.

impl Input for ParseContainer

type Item = char

The current input type is a sequence of that Item type.

type Iter = IntoIter<<ParseContainer as Input>::Item>

An iterator over the input type, producing the item

type IterIndices = IntoIter<(usize, <ParseContainer as Input>::Item)>

An iterator over the input type, producing the item and its byte position If we’re iterating over &str, the position corresponds to the byte index of the character

fn input_len(&self) -> usize

Calculates the input length, as indicated by its name, and the name of the trait itself

fn take(&self, index: usize) -> Self

Returns a slice of index bytes. panics if index > length

fn take_from(&self, index: usize) -> Self

Returns a slice starting at index bytes. panics if index > length

fn take_split(&self, index: usize) -> (Self, Self)

Split the stream at the index byte offset. panics if index > length

fn position<P>(&self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool,

Returns the byte position of the first element satisfying the predicate

fn iter_elements(&self) -> <Self as Input>::Iter

Returns an iterator over the elements

fn iter_indices(&self) -> <Self as Input>::IterIndices

Returns an iterator over the elements and their byte offsets

fn slice_index(&self, count: usize) -> Result<usize, Needed>

Get the byte offset from the element’s position in the stream

fn split_at_position<P, E>(&self, predicate: P) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1<P, E>( &self, predicate: P, e: ErrorKind, ) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

fn split_at_position_complete<P, E>( &self, predicate: P, ) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1_complete<P, E>( &self, predicate: P, e: ErrorKind, ) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

fn split_at_position_mode<OM, P, E>( &self, predicate: P, ) -> Result<(Self, <<OM as OutputMode>::Output as Mode>::Output<Self>), Err<E, <<OM as OutputMode>::Error as Mode>::Output<E>>>

where OM: OutputMode, E: ParseError<Self>, P: Fn(Self::Item) -> bool,

mode version of split_at_position

fn split_at_position_mode1<OM, P, E>( &self, predicate: P, e: ErrorKind, ) -> Result<(Self, <<OM as OutputMode>::Output as Mode>::Output<Self>), Err<E, <<OM as OutputMode>::Error as Mode>::Output<E>>>

where OM: OutputMode, E: ParseError<Self>, P: Fn(Self::Item) -> bool,

mode version of split_at_position

impl PartialEq<&str> for ParseContainer

fn eq(&self, rhs: &&str) -> 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 PartialEq<ParseContainer> for &str

fn eq(&self, rhs: &ParseContainer) -> 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 PartialEq for ParseContainer

fn eq(&self, rhs: &ParseContainer) -> 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.