pulsar-binary-protocol-spec 0.0.1

Pulsar binary protocol specification
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

macro_rules! make_x_respond_error {
    ($name:ident; $($variant:ident $ref:expr),*) => {
        use std::io::Error as IoError;

        use crate::{types::ServerError, frame::{FrameParseError, FrameRenderError}, client_handler::{WriteCommandError, ReadCommandError}};

        paste! {
            #[derive(thiserror::Error, Debug)]
            pub enum [<$name RespondError>] {
                #[error("FrameRenderError {0:?}")]
                FrameRenderError(#[from] FrameRenderError),

                #[error("WriteError {0:?}")]
                WriteError(IoError),

                #[error("ReadError {0:?}")]
                ReadError(IoError),

                #[error("FrameParseError {0:?}")]
                FrameParseError(#[from] FrameParseError),

                $(
                    #[error("{server_error:?} {msg}")]
                    [<SE $variant>] { server_error: ServerError, msg: String },
                )*

                #[error("Unimplemented {server_error:?} {msg}")]
                SEUnimplemented {
                    server_error: ServerError,
                    msg: String,
                },
            }

            impl From<(ServerError, &str)> for [<$name RespondError>] {
                fn from(t: (ServerError, &str)) -> Self {
                    let (se, msg) = t;
                    match se {
                        $(
                            ServerError::$variant => Self::[<SE $variant>] {
                                server_error: se,
                                msg: msg.to_owned(),
                            },
                        )*
                        _ => Self::SEUnimplemented {
                            server_error: se,
                            msg: msg.to_owned(),
                        },
                    }
                }
            }

            impl From<WriteCommandError> for [<$name RespondError>] {
                fn from(err: WriteCommandError) -> Self {
                    match err {
                        WriteCommandError::FrameRenderError(err) => Self::FrameRenderError(err),
                        WriteCommandError::WriteError(err) => Self::WriteError(err),
                    }
                }
            }

            impl From<ReadCommandError> for [<$name RespondError>] {
                fn from(err: ReadCommandError) -> Self {
                    match err {
                        ReadCommandError::ReadError(err) => Self::ReadError(err),
                        ReadCommandError::FrameParseError(err) => Self::FrameParseError(err),
                    }
                }
            }
        }
    };
}