Struct uri_rs::parser::parsers::Elms

pub struct Elms<'a> { /* fields omitted */ }

Custom Input Type

Implementations

impl<'a> Elms<'a>

pub fn new(values: &'a [u8]) -> Self

pub fn as_str(&self) -> Result<&str, Utf8Error>

pub fn as_string(&self) -> Result<String, FromUtf8Error>

Trait Implementations

impl<'a> AsBytes for Elms<'a>

fn as_bytes(&self) -> &[u8]

Casts the input type to a byte slice

impl<'a> Clone for Elms<'a>

fn clone(&self) -> Elms<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b> Compare<&'b str> for Elms<'a>

fn compare(&self, t: &'b str) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, t: &'b str) -> CompareResult

Compares self to another value for equality independently of the case.

impl<'a, 'b> Compare<Elms<'b>> for Elms<'a>

fn compare(&self, t: Elms<'b>) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, t: Elms<'b>) -> CompareResult

Compares self to another value for equality independently of the case.

impl ContextError<Elms<'_>> for UriParseError

fn add_context(_input: Elms<'_>, _ctx: &'static str, other: Self) -> Self

Creates a new error from an input position, a static string and an existing error. This is used mainly in the context combinator, to add user friendly information to errors when backtracking through a parse tree

impl<'a> Display for Elms<'a>

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

Formats the value using the given formatter.

impl From<Elms<'_>> for Scheme

fn from(src: Elms<'_>) -> Self

Performs the conversion.

impl<'a> InputIter for Elms<'a>

InputIter for Elms

This type provides essentially the same implementation as &’a u8.

type Item = u8

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

type Iter = Enumerate<Self::IterElem>

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

type IterElem = Copied<Iter<'a, u8>>

An iterator over the input type, producing the item

fn iter_indices(&self) -> Self::Iter

Returns an iterator over the elements and their byte offsets

fn iter_elements(&self) -> Self::IterElem

Returns an iterator over the elements

fn position<P>(&self, predicate: P) -> Option<usize> where
    P: Fn(Self::Item) -> bool, 

Finds the byte position of the element

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

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

impl<'a> InputLength for Elms<'a>

fn input_len(&self) -> usize

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

impl<'a> InputTake for Elms<'a>

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

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

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

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

impl<'a> InputTakeAtPosition for Elms<'a>

type Item = u8

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

fn split_at_position<P, E: ParseError<Self>>(
    &self,
    predicate: P
) -> IResult<Self, Self, E> where
    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: ParseError<Self>>(
    &self,
    predicate: P,
    e: ErrorKind
) -> IResult<Self, Self, E> where
    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: ParseError<Self>>(
    &self,
    predicate: P
) -> IResult<Self, Self, E> where
    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: ParseError<Self>>(
    &self,
    predicate: P,
    e: ErrorKind
) -> IResult<Self, Self, E> where
    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.

impl ParseError<Elms<'_>> for UriParseError

fn from_error_kind(input: Elms<'_>, kind: ErrorKind) -> Self

Creates an error from the input position and an ErrorKind

fn append(input: Elms<'_>, kind: ErrorKind, other: Self) -> Self

Combines an existing error with a new one created from the input position and an ErrorKind. This is useful when backtracking through a parse tree, accumulating error context on the way

fn from_char(input: Elms<'_>, c: char) -> Self

Creates an error from an input position and an expected character

fn or(self, other: Self) -> Self

Combines two existing errors. This function is used to compare errors generated in various branches of alt.

impl<'a> PartialEq<Elms<'a>> for Elms<'a>

fn eq(&self, other: &Elms<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Elms<'a>) -> bool

This method tests for !=.

impl<'a> Slice<Range<usize>> for Elms<'a>

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

Slices self according to the range argument

impl<'a> Slice<RangeFrom<usize>> for Elms<'a>

fn slice(&self, range: RangeFrom<usize>) -> Self

Slices self according to the range argument

impl<'a> Slice<RangeFull> for Elms<'a>

fn slice(&self, range: RangeFull) -> Self

Slices self according to the range argument

impl<'a> Slice<RangeTo<usize>> for Elms<'a>

fn slice(&self, range: RangeTo<usize>) -> Self

Slices self according to the range argument

impl<'a> StructuralPartialEq for Elms<'a>