Struct CodecLenValue

pub struct CodecLenValue<E, CodecEndian> { /* private fields */ }

Encodes and decodes a length prefixed value (TLV).

Encodes a value by prefixing it with its length using a fixed-size integer.

The length must either be a u8, or explicitly encoded in either big-endian by using CodecBe or little-endian by using CodecLe.

Examples

use devela::{Decodable, Encodable, CodecBe, CodecLenValue};

// Non-allocating
let mut buf = [0u8; 64];
let len = CodecLenValue::<_, u8>::new("hello").encode(&mut &mut buf[..]).unwrap();
assert_eq!(&buf[..len], &[5, b'h', b'e', b'l', b'l', b'o']);
//
let mut reader = &buf[..];
let decoded: &str = CodecLenValue::<&str, u8>::decode(&mut &mut reader).unwrap();
assert_eq!(decoded, "hello");

let lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud
exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure
dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.";
// Allocating
let mut buf = Vec::new();
let len = CodecLenValue::<_, CodecBe<u16>>::new(lorem).encode(&mut buf).unwrap();
assert_eq!(&buf[..7], &[1, 78, b'L', b'o', b'r', b'e', b'm'], "A big-endian u16 len");
assert_eq![len, 336];
//
let mut reader = buf.as_slice();
let decoded: String = CodecLenValue::<String, CodecBe<u16>>::decode(&mut reader).unwrap();
assert_eq!(decoded, lorem);

The length must fit the given type:

use devela::{Encodable, CodecLe, CodecLenValue};

let mut buf = Vec::new();
assert![CodecLenValue::<_, u8>::new("*".repeat(451)).encode(&mut buf).is_err()];
assert![CodecLenValue::<_, CodecLe<u16>>::new("*".repeat(451)).encode(&mut buf).is_ok()];

Vendored

This is adapted work from encode.

Implementations

impl<E, CodecEndian> CodecLenValue<E, CodecEndian>

pub const fn new(encodable: E) -> Self

Creates a new TLV combinator.

Trait Implementations

impl<E: Clone, CodecEndian: Clone> Clone for CodecLenValue<E, CodecEndian>

fn clone(&self) -> CodecLenValue<E, CodecEndian>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug, CodecEndian: Debug> Debug for CodecLenValue<E, CodecEndian>

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

Formats the value using the given formatter.

impl<'a, CodecEndian> Decodable<&'a mut &'a [u8]> for CodecLenValue<&'a str, CodecEndian>

where CodecEndian: CodecEndianLen + Decodable<&'a mut &'a [u8], Output = <CodecEndian as CodecEndianLen>::Len>, <CodecEndian as CodecEndianLen>::Len: TryInto<usize>,

type Output = &'a str

The type produced when decoding.

fn decode(reader: &mut &'a mut &'a [u8]) -> IoResult<Self::Output>

Decodes Self from the given reader, returning the decoded value.

impl<D, O, CodecEndian, R> Decodable<R> for CodecLenValue<D, CodecEndian>

where for<'i> D: Decodable<IoTake<&'i mut R>, Output = O>, CodecEndian: Decodable<R, Output = <CodecEndian as CodecEndianLen>::Len> + CodecEndianLen, R: IoRead, for<'r> &'r mut R: IoRead,

type Output = O

The type produced when decoding.

fn decode(reader: &mut R) -> IoResult<Self::Output>

Decodes Self from the given reader, returning the decoded value.

impl<E, CodecEndian, W: IoWrite> Encodable<W> for CodecLenValue<E, CodecEndian>

where E: Encodable<W> + EncodableLen, CodecEndian: From<<CodecEndian as CodecEndianLen>::Len> + Encodable<W> + CodecEndianLen, <CodecEndian as CodecEndianLen>::Len: TryFrom<usize>,

fn encode(&self, writer: &mut W) -> IoResult<usize>

Encodes self into the given writer, returning the bytes written.

impl<E: Ord, CodecEndian: Ord> Ord for CodecLenValue<E, CodecEndian>

fn cmp(&self, other: &CodecLenValue<E, CodecEndian>) -> 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<E: PartialEq, CodecEndian: PartialEq> PartialEq for CodecLenValue<E, CodecEndian>

fn eq(&self, other: &CodecLenValue<E, CodecEndian>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: PartialOrd, CodecEndian: PartialOrd> PartialOrd for CodecLenValue<E, CodecEndian>

fn partial_cmp(&self, other: &CodecLenValue<E, CodecEndian>) -> 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<E: Eq, CodecEndian: Eq> Eq for CodecLenValue<E, CodecEndian>

impl<E, CodecEndian> StructuralPartialEq for CodecLenValue<E, CodecEndian>