1#![no_std]
2mod message;
3mod metadata;
4pub use message::*;
5pub use metadata::*;
6pub use postcard::Error;
7use serde::{Deserialize, Serialize};
8#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
9pub enum Message<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> {
10 RequestIdentify(RequestIdentify<N>),
11 RequestOpen(RequestOpen<N>),
12 RequestClose(RequestClose),
13 RequestMetadata(RequestMetadata),
14 RequestSetmeta(RequestSetmeta),
15 RequestList(RequestList),
16 RequestMake(RequestMake<N>),
17 RequestRemove(RequestRemove<N>),
18 RequestRead(RequestRead),
19 RequestWrite(RequestWrite<C>),
20 RequestSeek(RequestSeek),
21 RequestTell(RequestTell),
22 RequestCopy(RequestCopy),
23 RequestLink(RequestLink<N>),
24 RequestDrop(RequestDrop),
25 ResponseError(ResponseError),
26 ResponseIdentify(ResponseIdentify),
27 ResponseOpen(ResponseOpen),
28 ResponseClose(ResponseClose),
29 ResponseMetadata(ResponseMetadata),
30 ResponseSetmeta(ResponseSetmeta),
31 ResponseList(ResponseList<N, E>),
32 ResponseMake(ResponseMake),
33 ResponseRemove(ResponseRemove),
34 ResponseRead(ResponseRead<C>),
35 ResponseWrite(ResponseWrite),
36 ResponseSeek(ResponseSeek),
37 ResponseTell(ResponseTell),
38 ResponseCopy(ResponseCopy),
39 ResponseLink(ResponseLink),
40 ResponseDrop(ResponseDrop),
41}
42impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> Message<N, C, E> {
43 pub fn to_slice<'ser>(&self, buf: &'ser mut [u8]) -> Result<&'ser mut [u8], postcard::Error>
44 where
45 N: Serialize,
46 C: Serialize,
47 E: Serialize,
48 {
49 postcard::to_slice(self, buf)
50 }
51 pub fn to_extend<W: Extend<u8>>(&self, writer: W) -> Result<W, postcard::Error>
52 where
53 N: Serialize,
54 C: Serialize,
55 E: Serialize,
56 {
57 postcard::to_extend(self, writer)
58 }
59 pub fn from_bytes<'de>(s: &'de [u8]) -> Result<Self, postcard::Error>
60 where
61 N: Deserialize<'de>,
62 C: Deserialize<'de>,
63 E: Deserialize<'de>,
64 {
65 postcard::from_bytes(s)
66 }
67 pub fn take_from_bytes<'de>(s: &'de [u8]) -> Result<(Self, &'de [u8]), postcard::Error>
68 where
69 N: Deserialize<'de>,
70 C: Deserialize<'de>,
71 E: Deserialize<'de>,
72 {
73 postcard::take_from_bytes(s)
74 }
75}
76#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
77pub enum Request<N: AsRef<str>, C: AsRef<[u8]>> {
78 Identify(RequestIdentify<N>),
79 Open(RequestOpen<N>),
80 Close(RequestClose),
81 Metadata(RequestMetadata),
82 Setmeta(RequestSetmeta),
83 List(RequestList),
84 Make(RequestMake<N>),
85 Remove(RequestRemove<N>),
86 Read(RequestRead),
87 Write(RequestWrite<C>),
88 Seek(RequestSeek),
89 Tell(RequestTell),
90 Copy(RequestCopy),
91 Link(RequestLink<N>),
92 Drop(RequestDrop),
93}
94impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> From<Request<N, C>> for Message<N, C, E> {
95 fn from(value: Request<N, C>) -> Self {
96 match value {
97 Request::Identify(identify) => Self::RequestIdentify(identify),
98 Request::Open(open) => Self::RequestOpen(open),
99 Request::Close(close) => Self::RequestClose(close),
100 Request::Metadata(metadata) => Self::RequestMetadata(metadata),
101 Request::Setmeta(setmeta) => Self::RequestSetmeta(setmeta),
102 Request::List(list) => Self::RequestList(list),
103 Request::Make(make) => Self::RequestMake(make),
104 Request::Remove(remove) => Self::RequestRemove(remove),
105 Request::Read(read) => Self::RequestRead(read),
106 Request::Write(write) => Self::RequestWrite(write),
107 Request::Seek(seek) => Self::RequestSeek(seek),
108 Request::Tell(tell) => Self::RequestTell(tell),
109 Request::Copy(copy) => Self::RequestCopy(copy),
110 Request::Link(link) => Self::RequestLink(link),
111 Request::Drop(drop) => Self::RequestDrop(drop),
112 }
113 }
114}
115impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> TryFrom<Message<N, C, E>>
116 for Request<N, C>
117{
118 type Error = Message<N, C, E>;
119 fn try_from(value: Message<N, C, E>) -> Result<Self, Self::Error> {
120 Ok(match value {
121 Message::RequestIdentify(identify) => Self::Identify(identify),
122 Message::RequestOpen(open) => Self::Open(open),
123 Message::RequestClose(close) => Self::Close(close),
124 Message::RequestMetadata(metadata) => Self::Metadata(metadata),
125 Message::RequestSetmeta(setmeta) => Self::Setmeta(setmeta),
126 Message::RequestList(list) => Self::List(list),
127 Message::RequestMake(make) => Self::Make(make),
128 Message::RequestRemove(remove) => Self::Remove(remove),
129 Message::RequestRead(read) => Self::Read(read),
130 Message::RequestWrite(write) => Self::Write(write),
131 Message::RequestSeek(seek) => Self::Seek(seek),
132 Message::RequestTell(tell) => Self::Tell(tell),
133 Message::RequestCopy(copy) => Self::Copy(copy),
134 Message::RequestLink(link) => Self::Link(link),
135 Message::RequestDrop(drop) => Self::Drop(drop),
136 other => return Err(other),
137 })
138 }
139}
140macro_rules! request {
141 ($variant:ident, $request:ty) => {
142 impl<N: AsRef<str>, C: AsRef<[u8]>> From<$request> for Request<N, C> {
143 fn from(value: $request) -> Self {
144 Self::$variant(value)
145 }
146 }
147 impl<N: AsRef<str>, C: AsRef<[u8]>> TryFrom<Request<N, C>> for $request {
148 type Error = Request<N, C>;
149 fn try_from(value: Request<N, C>) -> Result<Self, Self::Error> {
150 match value {
151 Request::$variant(as_self) => Ok(as_self),
152 other => Err(other),
153 }
154 }
155 }
156 };
157}
158request!(Identify, RequestIdentify<N>);
159request!(Open, RequestOpen<N>);
160request!(Close, RequestClose);
161request!(Metadata, RequestMetadata);
162request!(Setmeta, RequestSetmeta);
163request!(List, RequestList);
164request!(Make, RequestMake<N>);
165request!(Remove, RequestRemove<N>);
166request!(Read, RequestRead);
167request!(Write, RequestWrite<C>);
168request!(Seek, RequestSeek);
169request!(Tell, RequestTell);
170request!(Copy, RequestCopy);
171request!(Link, RequestLink<N>);
172request!(Drop, RequestDrop);
173#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
174pub enum Response<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> {
175 Error(ResponseError),
176 Identify(ResponseIdentify),
177 Open(ResponseOpen),
178 Close(ResponseClose),
179 Metadata(ResponseMetadata),
180 Setmeta(ResponseSetmeta),
181 List(ResponseList<N, E>),
182 Make(ResponseMake),
183 Remove(ResponseRemove),
184 Read(ResponseRead<C>),
185 Write(ResponseWrite),
186 Seek(ResponseSeek),
187 Tell(ResponseTell),
188 Copy(ResponseCopy),
189 Link(ResponseLink),
190 Drop(ResponseDrop),
191}
192impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> From<Response<N, C, E>> for Message<N, C, E> {
193 fn from(value: Response<N, C, E>) -> Self {
194 match value {
195 Response::Error(error) => Self::ResponseError(error),
196 Response::Identify(identify) => Self::ResponseIdentify(identify),
197 Response::Open(open) => Self::ResponseOpen(open),
198 Response::Close(close) => Self::ResponseClose(close),
199 Response::Metadata(metadata) => Self::ResponseMetadata(metadata),
200 Response::Setmeta(setmeta) => Self::ResponseSetmeta(setmeta),
201 Response::List(list) => Self::ResponseList(list),
202 Response::Make(make) => Self::ResponseMake(make),
203 Response::Remove(remove) => Self::ResponseRemove(remove),
204 Response::Read(read) => Self::ResponseRead(read),
205 Response::Write(write) => Self::ResponseWrite(write),
206 Response::Seek(seek) => Self::ResponseSeek(seek),
207 Response::Tell(tell) => Self::ResponseTell(tell),
208 Response::Copy(copy) => Self::ResponseCopy(copy),
209 Response::Link(link) => Self::ResponseLink(link),
210 Response::Drop(drop) => Self::ResponseDrop(drop),
211 }
212 }
213}
214impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> TryFrom<Message<N, C, E>>
215 for Response<N, C, E>
216{
217 type Error = Message<N, C, E>;
218 fn try_from(
219 value: Message<N, C, E>,
220 ) -> Result<Self, <Response<N, C, E> as TryFrom<Message<N, C, E>>>::Error> {
221 Ok(match value {
222 Message::ResponseError(error) => Self::Error(error),
223 Message::ResponseIdentify(identify) => Self::Identify(identify),
224 Message::ResponseOpen(open) => Self::Open(open),
225 Message::ResponseClose(close) => Self::Close(close),
226 Message::ResponseMetadata(metadata) => Self::Metadata(metadata),
227 Message::ResponseSetmeta(setmeta) => Self::Setmeta(setmeta),
228 Message::ResponseList(list) => Self::List(list),
229 Message::ResponseMake(make) => Self::Make(make),
230 Message::ResponseRemove(remove) => Self::Remove(remove),
231 Message::ResponseRead(read) => Self::Read(read),
232 Message::ResponseWrite(write) => Self::Write(write),
233 Message::ResponseSeek(seek) => Self::Seek(seek),
234 Message::ResponseTell(tell) => Self::Tell(tell),
235 Message::ResponseCopy(copy) => Self::Copy(copy),
236 Message::ResponseLink(link) => Self::Link(link),
237 Message::ResponseDrop(drop) => Self::Drop(drop),
238 other => return Err(other),
239 })
240 }
241}
242macro_rules! response {
243 ($response_variant:ident, $message_variant:ident, $response:ty) => {
244 impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> From<$response>
245 for Response<N, C, E>
246 {
247 fn from(value: $response) -> Self {
248 Self::$response_variant(value)
249 }
250 }
251 impl<N: AsRef<str>, C: AsRef<[u8]>, E: AsRef<[Entry<N>]>> TryFrom<Message<N, C, E>>
252 for $response
253 {
254 type Error = Message<N, C, E>;
255 fn try_from(value: Message<N, C, E>) -> Result<Self, Self::Error> {
256 match value {
257 Message::$message_variant(as_self) => Ok(as_self),
258 other => Err(other),
259 }
260 }
261 }
262 };
263}
264response!(Error, ResponseError, ResponseError);
265response!(Identify, ResponseIdentify, ResponseIdentify);
266response!(Open, ResponseOpen, ResponseOpen);
267response!(Close, ResponseClose, ResponseClose);
268response!(Metadata, ResponseMetadata, ResponseMetadata);
269response!(Setmeta, ResponseSetmeta, ResponseSetmeta);
270response!(List, ResponseList, ResponseList<N, E>);
271response!(Make, ResponseMake, ResponseMake);
272response!(Remove, ResponseRemove, ResponseRemove);
273response!(Read, ResponseRead, ResponseRead<C>);
274response!(Write, ResponseWrite, ResponseWrite);
275response!(Seek, ResponseSeek, ResponseSeek);
276response!(Tell, ResponseTell, ResponseTell);
277response!(Copy, ResponseCopy, ResponseCopy);
278response!(Link, ResponseLink, ResponseLink);
279response!(Drop, ResponseDrop, ResponseDrop);