Struct DynamicString 

pub struct DynamicString<Length, Encoding, Value> { /* private fields */ }

Dynamically sized string.

Encodes the size of the string in a preceding length field.

Examples

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

// A `DynamicString` encodes the size of the string in a preceeding length field.
let value = String::from("rsomeip");
let string = DynamicString::<LengthU32, Utf8, _>::from(&value);

// Size includes the length field, BOM, string, and delimiter.
assert_eq!(Some(15), string.size());
// Size hint only includes the length field.
assert_eq!(Some(4), DynamicString::<LengthU32, Utf8, String>::size_hint());

// Buffer can be any type that implements `BufMut`.
let mut buffer = [0_u8; 15];

// Serialized data includes Length, Byte Order Mark and Delimiter.
assert_eq!(Ok(15), string.serialize(&mut buffer.as_mut_slice()));
assert_eq!(buffer, [
        0x00_u8, 0x00, 0x00, 0x0b, // Length
        0xef, 0xbb, 0xbf, // UTF-8 BOM
        0x72, 0x73, 0x6f, 0x6d, 0x65, 0x69, 0x70, // "rsomeip"
        0x00, // Delimiter
    ]);

// Deserialization automatically strips the length, BOM, and delimiters.
let output = DynamicString::<LengthU32, Utf8, String>::deserialize(&mut buffer.as_slice())?;
assert_eq!(output, value);

Trait Implementations

impl<Length, Encoding, Value> Deserialize for DynamicString<Length, Encoding, Value>

where Length: Length, Encoding: Encoding, Value: From<String>,

type Output = Value

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, Encoding, Value> From<Value> for DynamicString<Length, Encoding, Value>

where Length: Length, Encoding: Encoding, Value: AsRef<str>,

fn from(value: Value) -> Self

Converts to this type from the input type.

impl<Length, Encoding, Value> Serialize for DynamicString<Length, Encoding, Value>

where Length: Length, Encoding: Encoding, Value: AsRef<str>,

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.