Struct ketos::bytes::Bytes

pub struct Bytes(_);

Shared byte string container

Methods

impl Bytes

pub fn new(v: Vec<u8>) -> Bytes

Creates an empty byte string.

pub fn is_empty(&self) -> bool

Returns whether the byte string is empty.

pub fn len(&self) -> usize

Returns the number of bytes contained in the byte string.

pub fn slice<R: RangeArgument<usize>>(&self, range: R) -> Bytes

Returns a subslice of the byte string.

pub fn into_bytes(self) -> Vec<u8>

Consumes the container and returns a Vec<u8>.

pub fn push(&mut self, b: u8)

Inserts a byte at the end of the byte string.

Trait Implementations

impl AsRef<[u8]> for Bytes

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

Performs the conversion.

impl Clone for Bytes

fn clone(&self) -> Bytes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bytes

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

Formats the value using the given formatter.

impl Deref for Bytes

type Target = [u8]

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Bytes

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

Mutably dereferences the value.

impl Eq for Bytes

impl<'a> Extend<&'a u8> for Bytes

fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = &'a u8>, 

Extends a collection with the contents of an iterator.

impl Extend<u8> for Bytes

fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = u8>, 

Extends a collection with the contents of an iterator.

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

fn from(b: &[u8]) -> Bytes

Performs the conversion.

impl<'a> From<&'a str> for Bytes

fn from(s: &str) -> Bytes

Performs the conversion.

impl From<Bytes> for Value

fn from(s: Bytes) -> Value

Performs the conversion.

impl From<String> for Bytes

fn from(s: String) -> Bytes

Performs the conversion.

impl From<Vec<u8>> for Bytes

fn from(b: Vec<u8>) -> Bytes

Performs the conversion.

impl FromValue for Bytes

fn from_value(v: Value) -> Result<Bytes, ExecError>

Consumes the Value and returns a Rust value

impl<'a> FromValueRef<'a> for &'a Bytes

fn from_value_ref(v: &'a Value) -> Result<&'a Bytes, ExecError>

Returns the borrowed value

impl<'a> IntoIterator for &'a Bytes

type Item = &'a u8

The type of the elements being iterated over.

type IntoIter = Iter<'a, u8>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, u8>

Creates an iterator from a value.

impl Ord for Bytes

fn cmp(&self, rhs: &Bytes) -> 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

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a> PartialEq<&'a [u8; 0]> for Bytes

fn eq(&self, rhs: &&'a [u8; 0]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 1]> for Bytes

fn eq(&self, rhs: &&'a [u8; 1]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 10]> for Bytes

fn eq(&self, rhs: &&'a [u8; 10]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 11]> for Bytes

fn eq(&self, rhs: &&'a [u8; 11]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 12]> for Bytes

fn eq(&self, rhs: &&'a [u8; 12]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 13]> for Bytes

fn eq(&self, rhs: &&'a [u8; 13]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 14]> for Bytes

fn eq(&self, rhs: &&'a [u8; 14]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 15]> for Bytes

fn eq(&self, rhs: &&'a [u8; 15]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 16]> for Bytes

fn eq(&self, rhs: &&'a [u8; 16]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 17]> for Bytes

fn eq(&self, rhs: &&'a [u8; 17]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 18]> for Bytes

fn eq(&self, rhs: &&'a [u8; 18]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 19]> for Bytes

fn eq(&self, rhs: &&'a [u8; 19]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 2]> for Bytes

fn eq(&self, rhs: &&'a [u8; 2]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 20]> for Bytes

fn eq(&self, rhs: &&'a [u8; 20]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 21]> for Bytes

fn eq(&self, rhs: &&'a [u8; 21]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 22]> for Bytes

fn eq(&self, rhs: &&'a [u8; 22]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 23]> for Bytes

fn eq(&self, rhs: &&'a [u8; 23]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 24]> for Bytes

fn eq(&self, rhs: &&'a [u8; 24]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 25]> for Bytes

fn eq(&self, rhs: &&'a [u8; 25]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 26]> for Bytes

fn eq(&self, rhs: &&'a [u8; 26]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 27]> for Bytes

fn eq(&self, rhs: &&'a [u8; 27]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 28]> for Bytes

fn eq(&self, rhs: &&'a [u8; 28]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 29]> for Bytes

fn eq(&self, rhs: &&'a [u8; 29]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 3]> for Bytes

fn eq(&self, rhs: &&'a [u8; 3]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 30]> for Bytes

fn eq(&self, rhs: &&'a [u8; 30]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 31]> for Bytes

fn eq(&self, rhs: &&'a [u8; 31]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 32]> for Bytes

fn eq(&self, rhs: &&'a [u8; 32]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 4]> for Bytes

fn eq(&self, rhs: &&'a [u8; 4]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 5]> for Bytes

fn eq(&self, rhs: &&'a [u8; 5]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 6]> for Bytes

fn eq(&self, rhs: &&'a [u8; 6]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 7]> for Bytes

fn eq(&self, rhs: &&'a [u8; 7]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 8]> for Bytes

fn eq(&self, rhs: &&'a [u8; 8]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8; 9]> for Bytes

fn eq(&self, rhs: &&'a [u8; 9]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<&'a [u8]> for Bytes

fn eq(&self, rhs: &&'a [u8]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 0]> for Bytes

fn eq(&self, rhs: &[u8; 0]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 1]> for Bytes

fn eq(&self, rhs: &[u8; 1]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 10]> for Bytes

fn eq(&self, rhs: &[u8; 10]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 11]> for Bytes

fn eq(&self, rhs: &[u8; 11]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 12]> for Bytes

fn eq(&self, rhs: &[u8; 12]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 13]> for Bytes

fn eq(&self, rhs: &[u8; 13]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 14]> for Bytes

fn eq(&self, rhs: &[u8; 14]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 15]> for Bytes

fn eq(&self, rhs: &[u8; 15]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 16]> for Bytes

fn eq(&self, rhs: &[u8; 16]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 17]> for Bytes

fn eq(&self, rhs: &[u8; 17]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 18]> for Bytes

fn eq(&self, rhs: &[u8; 18]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 19]> for Bytes

fn eq(&self, rhs: &[u8; 19]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 2]> for Bytes

fn eq(&self, rhs: &[u8; 2]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 20]> for Bytes

fn eq(&self, rhs: &[u8; 20]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 21]> for Bytes

fn eq(&self, rhs: &[u8; 21]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 22]> for Bytes

fn eq(&self, rhs: &[u8; 22]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 23]> for Bytes

fn eq(&self, rhs: &[u8; 23]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 24]> for Bytes

fn eq(&self, rhs: &[u8; 24]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 25]> for Bytes

fn eq(&self, rhs: &[u8; 25]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 26]> for Bytes

fn eq(&self, rhs: &[u8; 26]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 27]> for Bytes

fn eq(&self, rhs: &[u8; 27]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 28]> for Bytes

fn eq(&self, rhs: &[u8; 28]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 29]> for Bytes

fn eq(&self, rhs: &[u8; 29]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 3]> for Bytes

fn eq(&self, rhs: &[u8; 3]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 30]> for Bytes

fn eq(&self, rhs: &[u8; 30]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 31]> for Bytes

fn eq(&self, rhs: &[u8; 31]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 32]> for Bytes

fn eq(&self, rhs: &[u8; 32]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 4]> for Bytes

fn eq(&self, rhs: &[u8; 4]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 5]> for Bytes

fn eq(&self, rhs: &[u8; 5]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 6]> for Bytes

fn eq(&self, rhs: &[u8; 6]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 7]> for Bytes

fn eq(&self, rhs: &[u8; 7]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 8]> for Bytes

fn eq(&self, rhs: &[u8; 8]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8; 9]> for Bytes

fn eq(&self, rhs: &[u8; 9]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<[u8]> for Bytes

fn eq(&self, rhs: &[u8]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<Bytes> for Bytes

fn eq(&self, rhs: &Bytes) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<Vec<u8>> for Bytes

fn eq(&self, rhs: &Vec<u8>) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Bytes> for Bytes

fn partial_cmp(&self, rhs: &Bytes) -> Option<Ordering>

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

fn lt(&self, rhs: &Bytes) -> bool

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

fn le(&self, rhs: &Bytes) -> bool

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

fn gt(&self, rhs: &Bytes) -> bool

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

fn ge(&self, rhs: &Bytes) -> bool

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