1pub const REPE_SPEC: u16 = 0x1507;
5
6pub const REPE_VERSION: u8 = 1;
8
9pub const HEADER_SIZE: usize = 48;
11
12#[repr(u32)]
14#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
15#[non_exhaustive]
16pub enum ErrorCode {
17 Ok = 0,
19 VersionMismatch = 1,
21 InvalidHeader = 2,
24 InvalidQuery = 3,
27 InvalidBody = 4,
30 ParseError = 5,
33 MethodNotFound = 6,
35 Timeout = 7,
37 ResourceExhausted = 8,
45 InternalError = 9,
51 ApplicationErrorBase = 4096,
56}
57
58impl From<ErrorCode> for u32 {
59 fn from(v: ErrorCode) -> Self {
60 v as u32
61 }
62}
63
64impl core::convert::TryFrom<u32> for ErrorCode {
65 type Error = u32;
66 fn try_from(value: u32) -> Result<Self, Self::Error> {
67 let res = match value {
68 0 => ErrorCode::Ok,
69 1 => ErrorCode::VersionMismatch,
70 2 => ErrorCode::InvalidHeader,
71 3 => ErrorCode::InvalidQuery,
72 4 => ErrorCode::InvalidBody,
73 5 => ErrorCode::ParseError,
74 6 => ErrorCode::MethodNotFound,
75 7 => ErrorCode::Timeout,
76 8 => ErrorCode::ResourceExhausted,
77 9 => ErrorCode::InternalError,
78 4096 => ErrorCode::ApplicationErrorBase,
79 _ => return Err(value),
80 };
81 Ok(res)
82 }
83}
84
85#[repr(u16)]
87#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
88#[non_exhaustive]
89pub enum QueryFormat {
90 RawBinary = 0,
91 JsonPointer = 1,
92}
93
94impl From<QueryFormat> for u16 {
95 fn from(v: QueryFormat) -> Self {
96 v as u16
97 }
98}
99
100impl core::convert::TryFrom<u16> for QueryFormat {
101 type Error = u16;
102 fn try_from(value: u16) -> Result<Self, Self::Error> {
103 Ok(match value {
104 0 => QueryFormat::RawBinary,
105 1 => QueryFormat::JsonPointer,
106 other => return Err(other),
107 })
108 }
109}
110
111#[repr(u16)]
113#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
114#[non_exhaustive]
115pub enum BodyFormat {
116 RawBinary = 0,
117 Beve = 1, Json = 2,
119 Utf8 = 3,
120}
121
122impl From<BodyFormat> for u16 {
123 fn from(v: BodyFormat) -> Self {
124 v as u16
125 }
126}
127
128impl core::convert::TryFrom<u16> for BodyFormat {
129 type Error = u16;
130 fn try_from(value: u16) -> Result<Self, Self::Error> {
131 Ok(match value {
132 0 => BodyFormat::RawBinary,
133 1 => BodyFormat::Beve,
134 2 => BodyFormat::Json,
135 3 => BodyFormat::Utf8,
136 other => return Err(other),
137 })
138 }
139}
140
141impl std::fmt::Display for ErrorCode {
142 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
143 let s = match self {
144 ErrorCode::Ok => "OK",
145 ErrorCode::VersionMismatch => "Version mismatch",
146 ErrorCode::InvalidHeader => "Invalid header",
147 ErrorCode::InvalidQuery => "Invalid query",
148 ErrorCode::InvalidBody => "Invalid body",
149 ErrorCode::ParseError => "Parse error",
150 ErrorCode::MethodNotFound => "Method not found",
151 ErrorCode::Timeout => "Timeout",
152 ErrorCode::ResourceExhausted => "Resource exhausted",
153 ErrorCode::InternalError => "Internal error",
154 ErrorCode::ApplicationErrorBase => "Application error",
155 };
156 f.write_str(s)
157 }
158}