Struct Utf8 

pub struct Utf8;

UTF-8 encoding for strings.

Normally, used with StaticString and DynamicString.

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::<11, Utf8, _>::from(&value);

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

// Serialized data includes Byte Order Mark and Delimiter.
assert_eq!(Ok(11), 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
    ]);

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

Trait Implementations

impl Clone for Utf8

fn clone(&self) -> Utf8

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Utf8

impl Debug for Utf8

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

Formats the value using the given formatter.

impl Encoding for Utf8

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

where Value: AsRef<str>, Buffer: BufMut + ?Sized,

Serializes the value into the given buffer.

fn size<Value>(value: &Value) -> Option<usize>

where Value: AsRef<str> + ?Sized,

Returns the size of the value when serialized.

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

where Buffer: Buf + ?Sized,

Deserializes a null-terminated String from the given buffer.

impl Eq for Utf8

impl Hash for Utf8

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 PartialEq for Utf8

fn eq(&self, other: &Utf8) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Utf8