Struct cosey::Bytes

pub struct Bytes<N> where
    N: ArrayLength<u8>,  { /* fields omitted */ }

Methods

impl<N> Bytes<N> where
    N: ArrayLength<u8>, 

pub fn new() -> Bytes<N>

Construct a new, empty Bytes<N>.

pub fn from<T>(bytes: T) -> Bytes<N> where
    T: Into<Vec<u8, N>>, 

Wrap existing bytes in a Bytes<N>.

pub fn into_vec(self) -> Vec<u8, N>

Unwrap the vector of byte underlying this Bytes<N>.

pub fn try_from_slice(slice: &[u8]) -> Result<Bytes<N>, ()>

pub fn insert_slice_at(&mut self, slice: &[u8], at: usize) -> Result<(), ()>

pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()>

pub fn resize_to_capacity(&mut self)

Methods from Deref<Target = Vec<u8, N>>

pub fn capacity(&self) -> usize

Returns the maximum number of elements the vector can hold

pub fn clear(&mut self)

Clears the vector, removing all values.

pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), ()> where
    T: Clone, 

Clones and appends all elements in a slice to the Vec.

Iterates over the slice other, clones each element, and then appends it to this Vec. The other vector is traversed in-order.

Examples

use heapless::Vec;
use heapless::consts::*;

let mut vec = Vec::<u8, U8>::new();
vec.push(1).unwrap();
vec.extend_from_slice(&[2, 3, 4]).unwrap();
assert_eq!(*vec, [1, 2, 3, 4]);

pub fn pop(&mut self) -> Option<T>

Removes the last element from a vector and return it, or None if it's empty

pub fn push(&mut self, item: T) -> Result<(), T>

Appends an item to the back of the collection

Returns back the item if the vector is full

pub fn truncate(&mut self, len: usize)

Shortens the vector, keeping the first len elements and dropping the rest.

pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), ()> where
    T: Clone, 

Resizes the Vec in-place so that len is equal to new_len.

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with value. If new_len is less than len, the Vec is simply truncated.

See also resize_default.

pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()> where
    T: Clone + Default, 

Resizes the Vec in-place so that len is equal to new_len.

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with Default::default(). If new_len is less than len, the Vec is simply truncated.

See also resize.

pub fn swap_remove(&mut self, index: usize) -> T

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Panics

Panics if index is out of bounds.

Examples

use heapless::Vec;
use heapless::consts::*;

let mut v: Vec<_, U8> = Vec::new();
v.push("foo").unwrap();
v.push("bar").unwrap();
v.push("baz").unwrap();
v.push("qux").unwrap();

assert_eq!(v.swap_remove(1), "bar");
assert_eq!(&*v, ["foo", "qux", "baz"]);

assert_eq!(v.swap_remove(0), "foo");
assert_eq!(&*v, ["baz", "qux"]);

Trait Implementations

impl<N> AsMut<[u8]> for Bytes<N> where
    N: ArrayLength<u8>, 

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

Performs the conversion.

impl<N> AsRef<[u8]> for Bytes<N> where
    N: ArrayLength<u8>, 

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

Performs the conversion.

impl<N> Clone for Bytes<N> where
    N: Clone + ArrayLength<u8>, 

fn clone(&self) -> Bytes<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Debug for Bytes<N> where
    N: ArrayLength<u8>, 

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

Formats the value using the given formatter.

impl<N> Default for Bytes<N> where
    N: Default + ArrayLength<u8>, 

fn default() -> Bytes<N>

Returns the "default value" for a type.

impl<N> Deref for Bytes<N> where
    N: ArrayLength<u8>, 

type Target = Vec<u8, N>

The resulting type after dereferencing.

fn deref(&self) -> &<Bytes<N> as Deref>::Target

Dereferences the value.

impl<N> DerefMut for Bytes<N> where
    N: ArrayLength<u8>, 

fn deref_mut(&mut self) -> &mut <Bytes<N> as Deref>::Target

Mutably dereferences the value.

impl<'de, N> Deserialize<'de> for Bytes<N> where
    N: ArrayLength<u8>, 

fn deserialize<D>(
    deserializer: D
) -> Result<Bytes<N>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<N> Eq for Bytes<N> where
    N: Eq + ArrayLength<u8>, 

impl<N> Hash for Bytes<N> where
    N: ArrayLength<u8>, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<'a, N> IntoIterator for &'a Bytes<N> where
    N: ArrayLength<u8>, 

type Item = &'a u8

The type of the elements being iterated over.

type IntoIter = <&'a [u8] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Bytes<N> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<N> IntoIterator for Bytes<N> where
    N: ArrayLength<u8>, 

type Item = u8

The type of the elements being iterated over.

type IntoIter = <Vec<u8, N> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Bytes<N> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, N> IntoIterator for &'a mut Bytes<N> where
    N: ArrayLength<u8>, 

type Item = &'a mut u8

The type of the elements being iterated over.

type IntoIter = <&'a mut [u8] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Bytes<N> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<N, Rhs> PartialEq<Rhs> for Bytes<N> where
    N: ArrayLength<u8>,
    Rhs: AsRef<[u8]> + ?Sized, 

fn eq(&self, other: &Rhs) -> 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<N, Rhs> PartialOrd<Rhs> for Bytes<N> where
    N: ArrayLength<u8>,
    Rhs: AsRef<[u8]> + ?Sized, 

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

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

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

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

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

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

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

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

#[must_use] 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<N> Serialize for Bytes<N> where
    N: ArrayLength<u8>, 

fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<N> StructuralEq for Bytes<N> where
    N: ArrayLength<u8>,