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

#![feature(associated_type_defaults)]
#![feature(const_type_name)]

pub mod client;
pub mod server;

pub mod error;
pub mod extensions;

mod util;

use error::Error;
use serde::{de::DeserializeOwned, Serialize};

use crate::{error::ErrorType, sealed::Sealed};

mod sealed {
    pub trait Sealed {}
}

/// Marker trait for request
pub trait Request: Serialize + Sealed {}

/// Marker trait for response
pub trait Response: Serialize + DeserializeOwned + Sealed {}

pub type ResponseMessage<T> = Result<T, ErrorType>;

macro_rules! impl_request {
    ($($t:ty),*) => {
        $(
            impl $crate::Sealed for $t {}
            impl $crate::Request for $t {}
        )*
    };
}

macro_rules! impl_response {
    ($($t:ty),*) => {
        $(
            impl $crate::Sealed for $t {}
            impl $crate::Response for $t {}
        )*
    };
}

pub(crate) use impl_request;
pub(crate) use impl_response;

/// After connected, the client will send this request to the server
pub struct StreamRequestRequest<T: Request> {
    pub request: T,
}

/// Response of [`StreamRequestRequest`],
pub struct StreamRequestResponse {
    pub request_id: String,
    pub fail_reason: Option<ErrorType>,
    pub count: u32,
}

/// Subsequent messages requested by [`StreamRequestResponse`]. The server will
/// continuously send this message to the client
pub struct StreamResponse<T: Response> {
    pub request_id: String,
    pub count: u32,
    pub response: T,
}