Struct CodecError

Source

pub struct CodecError { /* private fields */ }

Expand description

Error returned by canonical encoding and decoding operations.

Implementations§

Source §

impl CodecError

Source

pub const fn new(kind: CodecErrorKind, message: &'static str) -> Self

Creates a new codec error with a stable kind and actionable message.

Source

pub const fn kind(&self) -> CodecErrorKind

Returns the stable error category.

Examples found in repository ?

examples/protocol_message.rs (line 72)

58fn main() -> Result<(), CodecError> {
59    let message = ProtocolMessage {
60        id: 42,
61        kind: MessageKind::Data(vec![1, 2, 3]),
62    };
63
64    let encoded = encode_to_vec(&message)?;
65    assert_eq!(encoded, [42, 0, 0, 0, 1, 3, 0, 0, 0, 1, 2, 3]);
66    assert_eq!(
67        decode_from_slice_exact::<ProtocolMessage>(&encoded)?,
68        message
69    );
70
71    let err = decode_from_slice_exact::<MessageKind>(&[9]).unwrap_err();
72    assert_eq!(err.kind(), CodecErrorKind::InvalidValue);
73    assert!(err.message().contains("unknown MessageKind tag"));
74
75    Ok(())
76}

More examples

Hide additional examples

examples/basic_encoding.rs (line 21)

5fn main() -> Result<(), CodecError> {
6    let port = 8080u16;
7    let encoded = encode_to_vec(&port)?;
8    assert_eq!(encoded, [0x90, 0x1f]);
9    assert_eq!(decode_from_slice_exact::<u16>(&encoded)?, port);
10
11    let text = "api";
12    let encoded = encode_to_vec(text)?;
13    assert_eq!(encoded, [3, 0, 0, 0, b'a', b'p', b'i']);
14    assert_eq!(decode_from_slice_exact::<String>(&encoded)?, text);
15
16    let (value, remaining) = decode_from_slice::<u8>(&[1, 2])?;
17    assert_eq!(value, 1);
18    assert_eq!(remaining, 1);
19
20    let err = decode_from_slice_exact::<u8>(&[1, 2]).unwrap_err();
21    assert_eq!(err.kind(), CodecErrorKind::TrailingBytes);
22
23    Ok(())
24}

Source

pub const fn message(&self) -> &'static str

Returns a human-readable error message.

Examples found in repository ?

examples/protocol_message.rs (line 73)

58fn main() -> Result<(), CodecError> {
59    let message = ProtocolMessage {
60        id: 42,
61        kind: MessageKind::Data(vec![1, 2, 3]),
62    };
63
64    let encoded = encode_to_vec(&message)?;
65    assert_eq!(encoded, [42, 0, 0, 0, 1, 3, 0, 0, 0, 1, 2, 3]);
66    assert_eq!(
67        decode_from_slice_exact::<ProtocolMessage>(&encoded)?,
68        message
69    );
70
71    let err = decode_from_slice_exact::<MessageKind>(&[9]).unwrap_err();
72    assert_eq!(err.kind(), CodecErrorKind::InvalidValue);
73    assert!(err.message().contains("unknown MessageKind tag"));
74
75    Ok(())
76}

Source

pub const fn unexpected_eof() -> Self

Input ended before the requested bytes could be read.

Source

pub const fn invalid_value(message: &'static str) -> Self

Value used an invalid byte or tag.

Examples found in repository ?

examples/protocol_message.rs (lines 51-53)

47    fn decode<R: DecodeSource + ?Sized>(reader: &mut R) -> Result<Self, CodecError> {
48        match u8::decode(reader)? {
49            0 => Ok(Self::Ping),
50            1 => Vec::<u8>::decode(reader).map(Self::Data),
51            _ => Err(CodecError::invalid_value(
52                "unknown MessageKind tag: expected 0x00 or 0x01",
53            )),
54        }
55    }