binja 0.3.2

A simple and efficient binary serializer and deserializer for Rust.
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
147
148
149
150
151
152
153
154
155
156
157
158
159

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

use bytes::TryGetError;
#[cfg(feature = "serde")]
use serde::{de, ser};

// A type alias for Result that uses the custom Error enum
pub type Result<T> = std::result::Result<T, Error>;

// Defining a custom Error enum to represent various error types
#[derive(Clone, Debug, PartialEq)]
pub enum Error {
    // A generic error message
    Message(String),

    // Error for invalid types with expected and found descriptions
    InvalidType {
        expected: String,
        found: String,
    },
    // Error for invalid values with expected and found descriptions
    InvalidValue {
        expected: String,
        found: String,
    },
    // Error for invalid lengths with expected and found descriptions
    InvalidLength {
        expected: String,
        found: String,
    },
    // Error for invalid variants with expected and found descriptions
    InvalidVariant {
        expected: String,
        found: String,
    },
    // Error for unknown fields with the field name and expected fields
    UnknownField {
        field: String,
        expected: Vec<String>,
    },
    // Error for missing fields with the field name
    MissingField {
        field: String,
    },
    // Error for duplicate fields with the field name
    DuplicateField {
        field: String,
    },

    LimitExceeded {
        limit: usize,
        size: usize,
    },

    NoEnoughData {
        expected: usize,
        available: usize,
    },

    InvalidBoolValue(u8),

    InvalidUtf8 {
        value: Vec<u8>,
    },

    Overflow {
        value: String,
        max: String,
    },
}

// Implementing the standard Error trait for the custom Error enum
impl std::error::Error for Error {}

// Implementing the serde::ser::Error trait for serialization errors
#[cfg(feature = "serde")]
impl ser::Error for Error {
    // Converts a custom message into an Error::Message variant
    fn custom<T: Display>(msg: T) -> Self {
        Error::Message(msg.to_string())
    }
}

// Implementing the serde::de::Error trait for deserialization errors
#[cfg(feature = "serde")]
impl de::Error for Error {
    // Converts a custom message into an Error::Message variant
    fn custom<T: Display>(msg: T) -> Self {
        Error::Message(msg.to_string())
    }
}

impl Display for Error {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::Message(msg) => formatter.write_str(msg),
            Error::InvalidType { expected, found } => {
                write!(
                    formatter,
                    "Invalid type: expected {expected}, found {found}"
                )
            }
            Error::InvalidValue { expected, found } => {
                write!(
                    formatter,
                    "Invalid value: expected {expected}, found {found}"
                )
            }
            Error::InvalidLength { expected, found } => {
                write!(
                    formatter,
                    "Invalid length: expected {expected}, found {found}"
                )
            }
            Error::InvalidVariant { expected, found } => {
                write!(
                    formatter,
                    "Invalid variant: expected {expected}, found {found}"
                )
            }
            Error::UnknownField { field, expected } => {
                write!(
                    formatter,
                    "Unknown field: {field}. Expected fields: {expected:?}"
                )
            }
            Error::MissingField { field } => write!(formatter, "Missing field: {field}"),
            Error::DuplicateField { field } => write!(formatter, "Duplicate field: {field}"),
            Error::LimitExceeded { limit, size } => {
                write!(formatter, "Limit exceeded: limit {limit}, size {size}")
            }
            Error::NoEnoughData {
                expected,
                available,
            } => {
                write!(
                    formatter,
                    "Not enough data: expected {expected}, available {available}"
                )
            }
            Error::InvalidBoolValue(value) => write!(formatter, "Invalid boolean value: {value}"),
            Error::InvalidUtf8 { value } => {
                write!(formatter, "Invalid UTF-8 sequence: {value:?}")
            }
            Error::Overflow { value, max } => {
                write!(formatter, "Overflow: value {value}, max {max}")
            }
        }
    }
}

impl From<TryGetError> for Error {
    fn from(value: TryGetError) -> Self {
        Error::NoEnoughData {
            expected: value.requested,
            available: value.available,
        }
    }
}