Struct VB6Stream 

pub struct VB6Stream<'a> {
    pub file_path: String,
    pub stream: &'a BStr,
    pub index: usize,
    pub line_number: usize,
    pub column: usize,
}

Fields

file_path: String

stream: &'a BStr

index: usize

line_number: usize

column: usize

Implementations

impl<'a> VB6Stream<'a>

pub fn new(file_path: impl Into<String>, stream: &'a [u8]) -> Self

pub fn is_empty(&self) -> bool

pub fn error(&self, kind: VB6ErrorKind) -> VB6Error

Trait Implementations

impl<'a> Clone for VB6Stream<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Compare<&str> for VB6Stream<'a>

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

Compares self to another value for equality

impl<'a> Compare<Caseless<&str>> for VB6Stream<'a>

fn compare(&self, other: Caseless<&str>) -> CompareResult

Compares self to another value for equality

impl<'a> Compare<char> for VB6Stream<'a>

fn compare(&self, other: char) -> CompareResult

Compares self to another value for equality

impl<'a> Debug for VB6Stream<'a>

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

Formats the value using the given formatter.

impl<'a> Default for VB6Stream<'a>

fn default() -> VB6Stream<'a>

Returns the “default value” for a type.

impl<'a> FindSlice<&str> for VB6Stream<'a>

fn find_slice(&self, needle: &str) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(&str, &str)> for VB6Stream<'a>

fn find_slice(&self, needle: (&str, &str)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(&str, &str, &str)> for VB6Stream<'a>

fn find_slice(&self, needle: (&str, &str, &str)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(&str, &str, &str, &str)> for VB6Stream<'a>

fn find_slice(&self, needle: (&str, &str, &str, &str)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(&str, &str, &str, &str, &str)> for VB6Stream<'a>

fn find_slice( &self, needle: (&str, &str, &str, &str, &str), ) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(&str, &str, &str, &str, &str, &str)> for VB6Stream<'a>

fn find_slice( &self, needle: (&str, &str, &str, &str, &str, &str), ) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(char, char)> for VB6Stream<'a>

fn find_slice(&self, needle: (char, char)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(u8, u8)> for VB6Stream<'a>

fn find_slice(&self, needle: (u8, u8)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(u8, u8, u8)> for VB6Stream<'a>

fn find_slice(&self, needle: (u8, u8, u8)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<(u8, u8, u8, u8)> for VB6Stream<'a>

fn find_slice(&self, needle: (u8, u8, u8, u8)) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<char> for VB6Stream<'a>

fn find_slice(&self, needle: char) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> FindSlice<u8> for VB6Stream<'a>

fn find_slice(&self, needle: u8) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<'a> Hash for VB6Stream<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for VB6Stream<'a>

fn cmp(&self, other: &VB6Stream<'a>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> ParserError<VB6Stream<'a>> for VB6Error

type Inner = VB6ErrorKind

Generally, Self

fn from_input(input: &VB6Stream<'a>) -> Self

Creates an error from the input position

fn into_inner(self) -> Result<Self::Inner, Self>

Unwrap the mode, returning the underlying error, if present

fn append( self, _: &VB6Stream<'_>, _: &<VB6Stream<'_> as Stream>::Checkpoint, ) -> Self

Like ParserError::from_input but merges it with the existing error.

fn assert(input: &I, _message: &'static str) -> Self

where I: Debug,

Process a parser assertion

fn incomplete(input: &I, _needed: Needed) -> Self

There was not enough data to determine the appropriate action

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

Combines errors from two different parse branches.

fn is_backtrack(&self) -> bool

Is backtracking and trying new parse branches allowed?

fn is_incomplete(&self) -> bool

Is more data Needed

fn needed(&self) -> Option<Needed>

Extract the Needed data, if present

impl<'a> ParserError<VB6Stream<'a>> for VB6ErrorKind

type Inner = VB6ErrorKind

Generally, Self

fn into_inner(self) -> Result<Self::Inner, Self>

Unwrap the mode, returning the underlying error, if present

fn from_input(_: &VB6Stream<'_>) -> Self

Creates an error from the input position

fn append( self, _: &VB6Stream<'_>, _: &<VB6Stream<'_> as Stream>::Checkpoint, ) -> Self

Like ParserError::from_input but merges it with the existing error.

fn assert(input: &I, _message: &'static str) -> Self

where I: Debug,

Process a parser assertion

fn incomplete(input: &I, _needed: Needed) -> Self

There was not enough data to determine the appropriate action

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

Combines errors from two different parse branches.

fn is_backtrack(&self) -> bool

Is backtracking and trying new parse branches allowed?

fn is_incomplete(&self) -> bool

Is more data Needed

fn needed(&self) -> Option<Needed>

Extract the Needed data, if present

impl<'a> PartialEq for VB6Stream<'a>

fn eq(&self, other: &VB6Stream<'a>) -> 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<'a> PartialOrd for VB6Stream<'a>

fn partial_cmp(&self, other: &VB6Stream<'a>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> Stream for VB6Stream<'a>

type Token = u8

The smallest unit being parsed

type Slice = &'a BStr

Sequence of Tokens

type IterOffsets = Enumerate<Copied<Iter<'a, u8>>>

Iterate with the offset from the current location

type Checkpoint = VB6StreamCheckpoint

A parse location within the stream

fn iter_offsets(&self) -> Self::IterOffsets

Iterate with the offset from the current location

fn eof_offset(&self) -> usize

Returns the offset to the end of the input

fn peek_token(&self) -> Option<Self::Token>

Split off the next token from the input

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

Split off a slice of tokens from the input

fn next_token(&mut self) -> Option<Self::Token>

Split off the next token from the input

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

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

Finds the offset of the next matching token

fn offset_at(&self, tokens: usize) -> Result<usize, Needed>

Get the offset for the number of tokens into the stream

fn next_slice(&mut self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

fn checkpoint(&self) -> Self::Checkpoint

Save the current parse location within the stream

fn reset(&mut self, checkpoint: &Self::Checkpoint)

Revert the stream to a prior Self::Checkpoint

fn raw(&self) -> &dyn Debug

Return the inner-most stream

unsafe fn next_slice_unchecked(&mut self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

unsafe fn peek_slice_unchecked(&self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

fn finish(&mut self) -> Self::Slice

Advance to the end of the stream

fn peek_finish(&self) -> Self::Slice

where Self: Clone,

Advance to the end of the stream

impl<'a> StreamIsPartial for VB6Stream<'a>

type PartialState = usize

Whether the stream is currently partial or complete

fn complete(&mut self) -> usize

Mark the stream is complete

fn is_partial(&self) -> bool

Report whether the Stream is currently incomplete

fn restore_partial(&mut self, state: Self::PartialState)

Restore the stream back to its previous state

fn is_partial_supported() -> bool

Report whether the Stream is can ever be incomplete

impl<'a> Eq for VB6Stream<'a>

impl<'a> StructuralPartialEq for VB6Stream<'a>