Struct ByteVec 

pub struct ByteVec;

Adapter for contiguous byte sequences that can be converted from Vec<u8>

Bytes is preferred if the type to serialize is an array. It avoids allocating a Vec when deserializing.

This allows optimized handling of byte sequences when serializing. This is similar to serde_bytes. Practically, this adapter allows serialization of bytes to go through Serializer::serialize_bytes and deserialization through Deserializer::deserialize_bytes or Deserializer::deserialize_byte_buf.

This adapter always serializes as a serde variable-length byte sequence, even if the collection type to serialize has a statically known length.

Example

use serde::{Deserialize, Serialize};

struct ByteWrapper(Vec<u8>);

impl From<Vec<u8>> for ByteWrapper {
    fn from(v: Vec<u8>) -> Self {
        Self(v)
    }
}

impl AsRef<[u8]> for ByteWrapper {
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
}

#[derive(Deserialize, Serialize)]
struct Foo {
    #[serde(with = "serdapt::ByteVec")]
    bytes: ByteWrapper,
}

Implementations

impl ByteVec

pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>

where T: ?Sized, S: Serializer, Self: SerializeWith<T>,

Serializes value as bytes

pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>

where D: Deserializer<'de>, Self: DeserializeWith<'de, T>,

Deserializes value from bytes

Trait Implementations

impl<'de, T> DeserializeWith<'de, T> for ByteVec

where T: TryFrom<Vec<u8>>, T::Error: Display,

fn deserialize_with<D>(deserializer: D) -> Result<T, D::Error>

where D: Deserializer<'de>,

Deserializes a value using deserializer

impl<T> SerializeWith<T> for ByteVec

where T: AsRef<[u8]> + ?Sized,

fn serialize_with<S: Serializer>( value: &T, serializer: S, ) -> Result<S::Ok, S::Error>

Serializes value using serializer