Struct StaticString 

pub struct StaticString<const N: usize, Encoding, Value> { /* private fields */ }

Statically sizes string.

Serialized static strings always have the same length regardless of the size of the actual string.

Extra space is padded with delimiters.

Examples

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

// A `StaticString` can be used to always write the same amount of data regardless
// of the size of the string.
let value = String::from("rsomeip");
let string = StaticString::<15, Utf8, _>::from(&value);

// Size is the capacity of the underlying array.
assert_eq!(Some(15), string.size());
assert_eq!(Some(15), StaticString::<15, Utf8, String>::size_hint());

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

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

// Deserialization automatically strips the BOM, delimiter, and padding.
let output = StaticString::<15, Utf8, String>::deserialize(&mut buffer.as_slice())?;
assert_eq!(output, value);

Trait Implementations

impl<Encoding, Value, const N: usize> Deserialize for StaticString<N, Encoding, Value>

where 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<Encoding, Value, const N: usize> From<Value> for StaticString<N, Encoding, Value>

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

fn from(value: Value) -> Self

Converts to this type from the input type.

impl<Encoding, Value, const N: usize> Serialize for StaticString<N, Encoding, Value>

where 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.