Struct cbor_smol::Bytes

pub struct Bytes<const N: usize> { /* fields omitted */ }

Implementations

impl<const N: usize> Bytes<N>

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_inner(self) -> Vec<u8, N>

Unwraps the Vec<u8, N>, same as into_vec.

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

Unwraps the Vec<u8, N>, same as into_inner.

pub fn as_slice(&self) -> &[u8]

Returns an immutable slice view.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns a mutable slice view.

pub fn try_convert_into<const M: usize>(&self) -> Result<Bytes<M>, ()>

Low-noise conversion between lengths.

We can’t implement TryInto since it would clash with blanket implementations.

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

pub fn try_from<E>(
    f: impl FnOnce(&mut [u8]) -> Result<usize, E>
) -> Result<Bytes<N>, E>

Some APIs offer an interface of the form f(&mut [u8]) -> Result<usize, E>, with the contract that the Ok-value signals how many bytes were written.

This constructor allows wrapping such interfaces in a more ergonomic way, returning a Bytes willed using f.

It seems it’s not possible to do this as an actual TryFrom implementation.

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

pub fn insert(&mut self, index: usize, item: u8) -> Result<(), u8>

pub fn remove(&mut self, index: usize) -> Result<u8, ()>

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

pub fn resize_to_capacity(&mut self)

pub fn to_bytes<const M: usize>(&self) -> Result<Bytes<M>, ()>

Fallible conversion into differently sized byte buffer.

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

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

Examples

use heapless::Vec;
let buffer: Vec<u8, 5> = Vec::from_slice(&[1, 2, 3, 5, 8]).unwrap();
assert_eq!(buffer.as_slice(), &[1, 2, 3, 5, 8]);

pub const 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<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

Extends the vec from an iterator.

Panic

Panics if the vec cannot hold all elements of the iterator.

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;

let mut vec = Vec::<u8, 8>::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 returns 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 unsafe fn push_unchecked(&mut self, item: T)

Appends an item to the back of the collection

Safety

This assumes the vec is not 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 unsafe fn set_len(&mut self, new_len: usize)

Forces the length of the vector to new_len.

This is a low-level operation that maintains none of the normal invariants of the type. Normally changing the length of a vector is done using one of the safe operations instead, such as truncate, resize, extend, or clear.

Safety

• new_len must be less than or equal to capacity().
• The elements at old_len..new_len must be initialized.

Examples

This method can be useful for situations in which the vector is serving as a buffer for other code, particularly over FFI:

use heapless::Vec;

pub fn get_dictionary(&self) -> Option<Vec<u8, 32768>> {
    // Per the FFI method's docs, "32768 bytes is always enough".
    let mut dict = Vec::new();
    let mut dict_length = 0;
    // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:
    // 1. `dict_length` elements were initialized.
    // 2. `dict_length` <= the capacity (32_768)
    // which makes `set_len` safe to call.
    unsafe {
        // Make the FFI call...
        let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
        if r == Z_OK {
            // ...and update the length to what was initialized.
            dict.set_len(dict_length);
            Some(dict)
        } else {
            None
        }
    }
}

While the following example is sound, there is a memory leak since the inner vectors were not freed prior to the set_len call:

use core::iter::FromIterator;
use heapless::Vec;

let mut vec = Vec::<Vec<u8, 3>, 3>::from_iter(
    [
        Vec::from_iter([1, 0, 0].iter().cloned()),
        Vec::from_iter([0, 1, 0].iter().cloned()),
        Vec::from_iter([0, 0, 1].iter().cloned()),
    ]
    .iter()
    .cloned()
);
// SAFETY:
// 1. `old_len..0` is empty so no elements need to be initialized.
// 2. `0 <= capacity` always holds whatever `capacity` is.
unsafe {
    vec.set_len(0);
}

Normally, here, one would use clear instead to correctly drop the contents and thus not leak memory.

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;

let mut v: Vec<_, 8> = 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"]);

pub unsafe fn swap_remove_unchecked(&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).

Safety

Assumes index within bounds.

Examples

use heapless::Vec;

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

assert_eq!(unsafe { v.swap_remove_unchecked(1) }, "bar");
assert_eq!(&*v, ["foo", "qux", "baz"]);

assert_eq!(unsafe { v.swap_remove_unchecked(0) }, "foo");
assert_eq!(&*v, ["baz", "qux"]);

pub fn is_full(&self) -> bool

Returns true if the vec is full

pub fn starts_with(&self, needle: &[T]) -> bool where
    T: PartialEq<T>, 

Returns true if needle is a prefix of the Vec.

Always returns true if needle is an empty slice.

Examples

use heapless::Vec;

let v: Vec<_, 8> = Vec::from_slice(b"abc").unwrap();
assert_eq!(v.starts_with(b""), true);
assert_eq!(v.starts_with(b"ab"), true);
assert_eq!(v.starts_with(b"bc"), false);

pub fn ends_with(&self, needle: &[T]) -> bool where
    T: PartialEq<T>, 

Returns true if needle is a suffix of the Vec.

Always returns true if needle is an empty slice.

Examples

use heapless::Vec;

let v: Vec<_, 8> = Vec::from_slice(b"abc").unwrap();
assert_eq!(v.ends_with(b""), true);
assert_eq!(v.ends_with(b"ab"), false);
assert_eq!(v.ends_with(b"bc"), true);

Trait Implementations

impl<const N: usize> AsMut<[u8]> for Bytes<N>

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

Performs the conversion.

impl<const N: usize> AsRef<[u8]> for Bytes<N>

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

Performs the conversion.

impl<const N: usize> Clone for Bytes<N>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for Bytes<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for Bytes<N>

pub fn default() -> Bytes<N>

Returns the “default value” for a type.

impl<const N: usize> Deref for Bytes<N>

type Target = Vec<u8, N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<const N: usize> DerefMut for Bytes<N>

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

Mutably dereferences the value.

impl<'de, const N: usize> Deserialize<'de> for Bytes<N>

pub 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<const N: usize> From<Vec<u8, N>> for Bytes<N>

pub fn from(vec: Vec<u8, N>) -> Bytes<N>

Performs the conversion.

impl<const N: usize> Hash for Bytes<N>

pub 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<const N: usize> IntoIterator for Bytes<N>

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?

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

Creates an iterator from a value.

impl<'a, const N: usize> IntoIterator for &'a mut Bytes<N>

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?

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

Creates an iterator from a value.

impl<'a, const N: usize> IntoIterator for &'a Bytes<N>

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?

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

Creates an iterator from a value.

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

pub 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<Rhs, const N: usize> PartialOrd<Rhs> for Bytes<N> where
    Rhs: AsRef<[u8]> + ?Sized, 

pub 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<const N: usize> Serialize for Bytes<N>

pub 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<'a, const N: usize> Writer for &'a mut Bytes<N>

type Error = Error

The type of error returned when a write operation fails.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this write.

impl<const N: usize> Eq for Bytes<N>

impl<const N: usize> StructuralEq for Bytes<N>