Struct DynamicArray 

pub struct DynamicArray<Length, Collection> { /* private fields */ }

Dynamically sized array.

Used to serialize and deserialize arbitrary collections using specific length fields.

Works on any type that implements IntoIterator<Item = Serialize> which includes Vec<T>, BTreeMap<K, V>, and Option<T>.

The length can be LengthZero, LengthU8, LengthU16 or LengthU32 for 0, 8, 16, and 32 bit length fields, respectively.

Examples

use rsomeip_bytes::{Deserialize as _, DynamicArray, LengthU32, Serialize as _};

// Works on any value that implements `IntoIterator`.
let value = vec![1, 2, 3, 4, 5];

// Specify the size of the length field in the generic parameters. It will be included when
// serializing the value.
let array = DynamicArray::<LengthU32, _>::from(&value);

// The array also implements the `Serialize` trait.
let mut bytes = array.to_bytes()?;

// And `Deserialize`, as well.
let output = DynamicArray::<LengthU32, Vec<i32>>::deserialize(&mut bytes)?;
assert_eq!(value, output);

Trait Implementations

impl<Length: Clone, Collection: Clone> Clone for DynamicArray<Length, Collection>

fn clone(&self) -> DynamicArray<Length, Collection>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Length: Copy, Collection: Copy> Copy for DynamicArray<Length, Collection>

impl<Length: Debug, Collection: Debug> Debug for DynamicArray<Length, Collection>

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

Formats the value using the given formatter.

impl<Length, Collection> Deserialize for DynamicArray<Length, Collection>

where Length: Length, Collection: IntoIterator + FromIterator<<Collection::Item as Deserialize>::Output>, Collection::Item: Deserialize,

type Output = Collection

Type of the deserialized data.

fn deserialize<Buffer>( buffer: &mut Buffer, ) -> Result<Self::Output, DeserializeError>

where Buffer: Buf + ?Sized,

Deserializes an instance of Deserialize::Output from the buffer.

fn size_hint() -> Option<usize>

Returns the minimum size of a correctly serialized Self::Output.

impl<Length: Eq, Collection: Eq> Eq for DynamicArray<Length, Collection>

impl<Length, Collection> From<Collection> for DynamicArray<Length, Collection>

where Length: Length, Collection: IntoIterator + Copy, Collection::Item: Serialize,

fn from(collection: Collection) -> Self

Converts to this type from the input type.

impl<Length: Hash, Collection: Hash> Hash for DynamicArray<Length, Collection>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Length: Ord, Collection: Ord> Ord for DynamicArray<Length, Collection>

fn cmp(&self, other: &DynamicArray<Length, Collection>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Length: PartialEq, Collection: PartialEq> PartialEq for DynamicArray<Length, Collection>

fn eq(&self, other: &DynamicArray<Length, Collection>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Length: PartialOrd, Collection: PartialOrd> PartialOrd for DynamicArray<Length, Collection>

fn partial_cmp( &self, other: &DynamicArray<Length, Collection>, ) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<Length, Collection> Serialize for DynamicArray<Length, Collection>

where Length: Length, Collection: IntoIterator + Copy, Collection::Item: Serialize,

fn serialize<Buffer>( &self, buffer: &mut Buffer, ) -> Result<usize, SerializeError>

where Buffer: BufMut + ?Sized,

Serializes self into the given buffer.

fn size(&self) -> Option<usize>

Returns the size of self when serialized.

fn to_bytes(&self) -> Result<Bytes, SerializeError>

Returns self serialized into Bytes.

impl<Length: PartialEq, Collection: PartialEq> StructuralPartialEq for DynamicArray<Length, Collection>