Struct Input 

pub struct Input<'a> {
    bytes: &'a [u8],
}

Fields

bytes: &'a [u8]

Trait Implementations

impl<'a> AtEof for Input<'a>

fn at_eof(&self) -> bool

While it might be possible in some settings to determine that the connection has closed and no further data may arrive, it is quite irrelevant considering the particular syntax of GTP. The only use case would be determining malformed input which ends without proper termination but this is currently beyond the scope of this implementation.

impl<'a> Clone for Input<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, S> Compare<S> for Input<'a>

where &'a [u8]: Compare<S>,

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

compares self to another value for equality

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

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

impl<'a> From<&'a [u8]> for Input<'a>

fn from(bytes: &'a [u8]) -> Self

Converts to this type from the input type.

impl<'a> InputIter for Input<'a>

type Item = u8

type RawItem = u8

type Iter = Enumerator<'a>

type IterElem = Iterator<'a>

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::RawItem) -> bool,

finds the byte position of the element

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

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

impl<'a> InputLength for Input<'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 Input<'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> Offset for Input<'a>

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

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

impl<'a> ParseTo for Input<'a>

impl<'a, R> ParseTo<R> for Input<'a>

where for<'b> &'b [u8]: ParseTo<R>,

fn parse_to(&self) -> Option<R>

impl<'a> ParseTo<Value> for Input<'a>

fn parse_to(&self) -> Option<Value>

impl<'a> Slice for Input<'a>

impl<'a, R> Slice<R> for Input<'a>

where &'a [u8]: Slice<R>,

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

impl<'a> UnspecializedInput for Input<'a>

This allows us to use a default implementation for InputTakeAtPosition.