Struct nombytes::NomBytes

pub struct NomBytes(_, _);

A wrapper around bytes::Bytes to be able to use it with nom.

Implementations

impl NomBytes

pub fn new(bytes: Bytes) -> Self

Creates a new NomBytes wrapping the provided Bytes.

Examples

use bytes::Bytes;
use nombytes::NomBytes;

let b = Bytes::new();
let nb = NomBytes::new(b);

pub fn to_str(&self) -> &str

Returns a string slice to the contents of the inner Bytes.

Examples

use bytes::Bytes;
use nombytes::NomBytes;

let nb = NomBytes::new(Bytes::from("hello"));
assert_eq!(nb.to_str(), "hello");

Panics

Panics if the Bytes slice is not UTF-8.

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

Returns a string slice to the contents of the inner Bytes.

Examples

use bytes::Bytes;
use nombytes::NomBytes;

let nb = NomBytes::new(Bytes::from("hello"));
assert_eq!(nb.try_to_str().unwrap(), "hello");

Errors

Returns Err if the Bytes slice is not UTF-8 with a description as to why the provided slice is not UTF-8.

pub fn to_bytes(&self) -> Bytes

Returns a Bytes representing the real state of the inner one.

Be careful using a Bytes returned from this function to create a new NomBytes for use in the same parsing session, as due to an optimization in Bytes, creating an empty slice (e.g. asking for the slice of 0..0 or ..0, which nom sometimes does) results in a Bytes that is unrelated to its source, which causes later offset calculations to give incorrect results.

This behavior is accounted for internally, so as long as you stick to only using NomBytes directly without going to Bytes and back, you won’t be affected by this optimization behavior.

Examples

use bytes::Bytes;
use nombytes::NomBytes;

let nb = NomBytes::new(Bytes::from("hello"));
let b = nb.to_bytes();
assert_eq!(b.as_ref(), b"hello");

pub fn into_bytes(self) -> Bytes

Returns a Bytes representing the real state of the inner one.

Be careful using a Bytes returned from this function to create a new NomBytes for use in the same parsing session, as due to an optimization in Bytes, creating an empty slice (e.g. asking for the slice of 0..0 or ..0, which nom sometimes does) results in a Bytes that is unrelated to its source, which causes later offset calculations to give incorrect results.

This behavior is accounted for internally, so as long as you stick to only using NomBytes directly without going to Bytes and back, you won’t be affected by this optimization behavior.

Examples

use bytes::Bytes;
use nombytes::NomBytes;

let nb = NomBytes::new(Bytes::from("hello"));
let b = nb.into_bytes();
assert_eq!(b.as_ref(), b"hello");

pub fn into_raw(self) -> (Bytes, Option<RangeType<usize>>)

Returns the values from the inner representation of this type.

See into_bytes for an explanation of why this inner representation exists.

pub fn from_raw((bytes, range_type): (Bytes, Option<RangeType<usize>>)) -> Self

Returns a new NomBytes using the raw values passed in. If these values represent something invalid, you’ll likely see incorrect behavior or even panics. Regular usage should create values using new instead.

See into_bytes for an explanation of why this inner representation exists.

Trait Implementations

impl AsBytes for NomBytes

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

Casts the input type to a byte slice

impl Clone for NomBytes

fn clone(&self) -> NomBytes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compare<&str> for NomBytes

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

Compares self to another value for equality

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

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

impl Compare<NomBytes> for NomBytes

fn compare(&self, t: NomBytes) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, t: NomBytes) -> CompareResult

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

impl Debug for NomBytes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NomBytes

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for NomBytes

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

Formats the value using the given formatter.

impl From<&[u8]> for NomBytes

fn from(byte_slice: &[u8]) -> Self

Converts to this type from the input type.

impl From<&str> for NomBytes

fn from(string: &str) -> Self

Converts to this type from the input type.

impl From<String> for NomBytes

fn from(string: String) -> Self

Converts to this type from the input type.

impl InputIter for NomBytes

type Item = u8

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

type Iter = Enumerate<<NomBytes as InputIter>::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 = IntoIter<Bytes>

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 InputLength for NomBytes

fn input_len(&self) -> usize

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

impl InputTake for NomBytes

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 InputTakeAtPosition for NomBytes

type Item = <NomBytes as InputIter>::Item

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 Offset for NomBytes

fn offset(&self, second: &Self) -> usize

Offset between the first byte of self and the first byte of the argument

impl Ord for NomBytes

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<NomBytes> for NomBytes

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

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

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

This method tests for !=.

impl PartialOrd<NomBytes> for NomBytes

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for NomBytes

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

Serialize this value into the given Serde serializer.

impl Slice<Range<usize>> for NomBytes

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

Slices self according to the range argument

impl Slice<RangeFrom<usize>> for NomBytes

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

Slices self according to the range argument

impl Slice<RangeFull> for NomBytes

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

Slices self according to the range argument

impl Slice<RangeTo<usize>> for NomBytes

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

Slices self according to the range argument

impl SourceCode for NomBytes

fn read_span<'a>(
    &'a self,
    span: &SourceSpan,
    context_lines_before: usize,
    context_lines_after: usize
) -> Result<Box<dyn SpanContents<'a> + 'a>, MietteError>

Read the bytes for a specific span from this SourceCode, keeping a certain number of lines before and after the span as context.

impl Eq for NomBytes