serde-binary-adv 1.0.0-beta.2

A library for Serde to enable the serialization and deserialization of Rust structures to and from raw binary
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::fmt::{self, Display};
use std::{self, string::FromUtf8Error};

use serde::{de, ser};

/// Errors that can be thrown by the Serializer or Deserializer
#[derive(Debug, Clone, PartialEq)]
pub enum BinaryError {
	/// A message only error
	Message {
		/// The test of the message
		message: String,
	},

	/// unexpected end of input
	UnexpectedEndOfInput,
	/// an invalid set of bytes for the type expected
	InvalidBytes,
	/// missing or invalid flag
	MissingOrInvalidFlag {
		/// The actual value
		actual: u8,
		/// The expected value
		expected: u8,
	},
	/// inavlid length
	InvalidLength {
		/// The actual value
		actual: usize,
		/// The expected value
		expected: usize,
	},
	/// invalid name
	InvalidName {
		/// The actual value
		actual: String,
		/// The expected value
		expected: String,
	},
	/// unexpected type
	UnexpectedType,
}

impl ser::Error for BinaryError {
	fn custom<T: Display>(msg: T) -> Self {
		BinaryError::Message {
			message: msg.to_string(),
		}
	}
}

impl de::Error for BinaryError {
	fn custom<T: Display>(msg: T) -> Self {
		BinaryError::Message {
			message: msg.to_string(),
		}
	}
}

impl Display for BinaryError {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match self {
			BinaryError::Message { message } => write!(f, "{}", message),
			BinaryError::UnexpectedEndOfInput => write!(f, "unexpected end of input"),
			BinaryError::InvalidBytes => write!(f, "invalid byte sequence"),
			BinaryError::MissingOrInvalidFlag { actual, expected } => write!(
				f,
				"missing or invalid type flag, actual 0x{:X}, expected 0x{:X}",
				actual, expected
			),
			BinaryError::InvalidLength { actual, expected } => {
				write!(
					f,
					"invalid length, actual {}, expected {}",
					actual, expected
				)
			}
			BinaryError::InvalidName { actual, expected } => {
				write!(f, "invalid name, actual {}, expected {}", actual, expected)
			}
			BinaryError::UnexpectedType => write!(f, "unexpected type"),
		}
	}
}

impl std::error::Error for BinaryError {}

impl From<FromUtf8Error> for BinaryError {
	fn from(e: FromUtf8Error) -> Self {
		BinaryError::Message {
			message: format!("{:?}", e),
		}
	}
}

#[cfg(test)]
mod tests {
	use crate::BinaryError;

	#[test]
	fn test_display() {
		test_display_specific(
			BinaryError::Message {
				message: String::from("this is a test"),
			},
			"this is a test",
		);
		test_display_specific(BinaryError::InvalidBytes, "invalid byte sequence");
		test_display_specific(BinaryError::UnexpectedEndOfInput, "unexpected end of input");
		test_display_specific(BinaryError::UnexpectedType, "unexpected type");
		test_display_specific(BinaryError::UnexpectedEndOfInput, "unexpected end of input");
		test_display_specific(
			BinaryError::InvalidLength {
				actual: 2,
				expected: 1,
			},
			"invalid length, actual 2, expected 1",
		);
		test_display_specific(
			BinaryError::InvalidName {
				actual: String::from("actual"),
				expected: String::from("expected"),
			},
			"invalid name, actual actual, expected expected",
		);
		test_display_specific(
			BinaryError::MissingOrInvalidFlag {
				actual: 0xff,
				expected: 0x80,
			},
			"missing or invalid type flag, actual 0xFF, expected 0x80",
		);
	}

	fn test_display_specific(error: BinaryError, expected: &str) {
		assert_eq!(format!("{}", error), expected);
	}

	#[test]
	fn test_error() {
		let e = <BinaryError as serde::ser::Error>::custom("test");
		test_display_specific(e, "test");
		let f = <BinaryError as serde::de::Error>::custom("test");
		test_display_specific(f, "test");
	}
}