Enum Either

pub enum Either<A, B> {
    A(A),
    B(B),
}

Either of two buffers.

An Either wraps one of two different buffer types. It implements all of the relevant traits by calling the corresponding methods on the wrapped buffer.

Variants

A(A)

B(B)

Implementations

impl<A, B> Either<A, B>

pub fn map_a<AA, F: FnOnce(A) -> AA>(self, f: F) -> Either<AA, B>

Maps the A variant of an Either.

Given an Either<A, B> and a function from A to AA, map_a produces an Either<AA, B> by applying the function to the A variant or passing on the B variant unmodified.

pub fn map_b<BB, F: FnOnce(B) -> BB>(self, f: F) -> Either<A, BB>

Maps the B variant of an Either.

Given an Either<A, B> and a function from B to BB, map_b produces an Either<A, BB> by applying the function to the B variant or passing on the A variant unmodified.

pub fn unwrap_a(self) -> A

Returns the A variant in an Either<A, B>.

Panics

Panics if this Either<A, B> does not hold the A variant.

pub fn unwrap_b(self) -> B

Returns the B variant in an Either<A, B>.

Panics

Panics if this Either<A, B> does not hold the B variant.

impl<A> Either<A, A>

pub fn into_inner(self) -> A

Returns the inner value held by this Either when both possible values Either::A and Either::B contain the same inner types.

impl<A> Either<A, Infallible>

pub fn into_a(self) -> A

Returns the A value in an Either<A, Never>.

impl<B> Either<Infallible, B>

pub fn into_b(self) -> B

Returns the B value in an Either<Never, B>.

Trait Implementations

impl<A: AsMut<[u8]>, B: AsMut<[u8]>> AsMut<[u8]> for Either<A, B>

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<A: AsRef<[u8]>, B: AsRef<[u8]>> AsRef<[u8]> for Either<A, B>

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<A, B> Buffer for Either<A, B>

where A: Buffer, B: Buffer,

fn parse_with_view<'a, ParseArgs, P: ParsablePacket<&'a [u8], ParseArgs>>( &'a mut self, args: ParseArgs, ) -> Result<(P, &'a [u8]), P::Error>

Like ParseBuffer::parse_with but additionally provides an un-structured view into the parsed data on successful parsing.

impl<I: ReusableBuffer, O: ReusableBuffer, A: BufferAlloc<O>> BufferProvider<I, Either<I, O>> for MaybeReuseBufferProvider<A>

fn reuse_or_realloc( self, buffer: I, need_prefix: usize, need_suffix: usize, ) -> Result<Either<I, O>, (A::Error, I)>

If buffer has enough capacity to store need_prefix + need_suffix + buffer.len() bytes, then reuse buffer. Otherwise, allocate a new buffer using A’s BufferAlloc implementation.

If there is enough capacity, but the body is too far forwards or backwards in the buffer to satisfy the prefix and suffix constraints, the body will be moved within the buffer in order to satisfy the constraints. This operation is linear in the length of the body.

type Error = <A as BufferAlloc<O>>::Error

The type of errors returned from reuse_or_realloc.

fn alloc_no_reuse( self, prefix: usize, body: usize, suffix: usize, ) -> Result<Either<I, O>, Self::Error>

Attempts to produce an output buffer with the given constraints by allocating a new one.

impl<A: Clone, B: Clone> Clone for Either<A, B>

fn clone(&self) -> Either<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Either<A, B>

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

Formats the value using the given formatter.

impl<A, B> FragmentedBuffer for Either<A, B>

where A: FragmentedBuffer, B: FragmentedBuffer,

fn len(&self) -> usize

Gets the total length, in bytes, of this FragmentedBuffer.

fn with_bytes<R, F>(&self, f: F) -> R

where F: for<'a, 'b> FnOnce(FragmentedBytes<'a, 'b>) -> R,

Invokes a callback on a view into this buffer’s contents as FragmentedBytes.

fn is_empty(&self) -> bool

Returns true if this FragmentedBuffer is empty.

fn to_flattened_vec(&self) -> Vec<u8>

Returns a flattened version of this buffer, copying its contents into a Vec.

impl<A, B> FragmentedBufferMut for Either<A, B>

where A: FragmentedBufferMut, B: FragmentedBufferMut,

fn with_bytes_mut<R, F>(&mut self, f: F) -> R

where F: for<'a, 'b> FnOnce(FragmentedBytesMut<'a, 'b>) -> R,

Invokes a callback on a mutable view into this buffer’s contents as FragmentedBytesMut.

fn zero_range<R>(&mut self, range: R)

where R: RangeBounds<usize>,

Sets all bytes in range to zero.

fn copy_within<R: RangeBounds<usize>>(&mut self, src: R, dst: usize)

Copies elements from one part of the FragmentedBufferMut to another part of itself.

fn copy_from<B: FragmentedBuffer>(&mut self, other: &B)

Copies all the bytes from another FragmentedBuffer other into self.

impl<A, B> GrowBuffer for Either<A, B>

where A: GrowBuffer, B: GrowBuffer,

fn with_parts<O, F>(&self, f: F) -> O

where F: for<'a, 'b> FnOnce(&'a [u8], FragmentedBytes<'a, 'b>, &'a [u8]) -> O,

Gets a view into the parts of this GrowBuffer.

fn capacity(&self) -> usize

The capacity of the buffer.

fn prefix_len(&self) -> usize

The length of the prefix.

fn suffix_len(&self) -> usize

The length of the suffix.

fn grow_front(&mut self, n: usize)

Grows the front of the body towards Growf the buffer.

fn grow_back(&mut self, n: usize)

Grows the back of the body towards the end of the buffer.

fn reset(&mut self)

Resets the body to be equal to the entire buffer.

fn undo_parse(&mut self, meta: ParseMetadata)

Undoes the effects of a previous parse in preparation for serialization.

impl<A, B> GrowBufferMut for Either<A, B>

where A: GrowBufferMut, B: GrowBufferMut,

fn with_parts_mut<O, F>(&mut self, f: F) -> O

where F: for<'a, 'b> FnOnce(&'a mut [u8], FragmentedBytesMut<'a, 'b>, &'a mut [u8]) -> O,

Gets a mutable view into the parts of this GrowBufferMut.

fn grow_front_zero(&mut self, n: usize)

Extends the front of the body towards the beginning of the buffer, zeroing the new bytes.

fn grow_back_zero(&mut self, n: usize)

Extends the back of the body towards the end of the buffer, zeroing the new bytes.

fn reset_zero(&mut self)

Resets the body to be equal to the entire buffer, zeroing the new bytes.

impl<A, B> ParseBuffer for Either<A, B>

where A: ParseBuffer, B: ParseBuffer,

fn parse<'a, P: ParsablePacket<&'a [u8], ()>>( &'a mut self, ) -> Result<P, P::Error>

Parses a packet from the body.

fn parse_with<'a, ParseArgs, P: ParsablePacket<&'a [u8], ParseArgs>>( &'a mut self, args: ParseArgs, ) -> Result<P, P::Error>

Parses a packet with arguments.

impl<A, B> ParseBufferMut for Either<A, B>

where A: ParseBufferMut, B: ParseBufferMut,

fn parse_mut<'a, P: ParsablePacket<&'a mut [u8], ()>>( &'a mut self, ) -> Result<P, P::Error>

Parses a mutable packet from the body.

fn parse_with_mut<'a, ParseArgs, P: ParsablePacket<&'a mut [u8], ParseArgs>>( &'a mut self, args: ParseArgs, ) -> Result<P, P::Error>

Parses a mutable packet with arguments.

impl<A, B> ShrinkBuffer for Either<A, B>

where A: ShrinkBuffer, B: ShrinkBuffer,

fn shrink<R: RangeBounds<usize>>(&mut self, range: R)

Shrinks the body.

fn shrink_front(&mut self, n: usize)

Shrinks the front of the body towards the end of the buffer.

fn shrink_back(&mut self, n: usize)

Shrinks the back of the body towards the beginning of the buffer.

fn shrink_front_to(&mut self, len: usize)

Shrinks the buffer to be no larger than len bytes, consuming from the front.

fn shrink_back_to(&mut self, len: usize)

Shrinks the buffer to be no larger than len bytes, consuming from the back.

impl<A, B> ContiguousBuffer for Either<A, B>

where A: ContiguousBuffer, B: ContiguousBuffer,

impl<A: Copy, B: Copy> Copy for Either<A, B>