jsonrpc-sys 0.1.4

JSON-RPC 2.0 types.
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

//! Utility functions for JSON-RPC 2.0.

use std::borrow::Cow;

use crate::{Error, ErrorCode, Id, Request, Response};

/// A type that cannot be serialized.
enum CantSerialize {}

impl serde::Serialize for CantSerialize {
    #[inline(always)]
    fn serialize<S>(&self, _: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match *self {}
    }
}

/// Writes a JSON-RPC 2.0 request with the provided method, params and ID to a vector of bytes.
pub fn write_request<'a, T>(
    method: &str,
    params: T,
    id: impl Into<Option<Id<'a>>>,
) -> serde_json::Result<Vec<u8>>
where
    T: serde::Serialize,
{
    let request = Request {
        method: Cow::Borrowed(method),
        params,
        id: id.into(),
    };
    serde_json::to_vec(&request)
}

/// Writes a JSON-RPC 2.0 response with the provided result and ID to a vector of bytes.
pub fn write_response<T, E>(result: Result<T, Error<E>>, id: Id) -> serde_json::Result<Vec<u8>>
where
    T: serde::Serialize,
    E: serde::Serialize,
{
    let response = Response { result, id };
    serde_json::to_vec(&response)
}

/// Writes a successful JSON-RPC 2.0 response with the provided result and ID to a vector of bytes.
pub fn write_success<T>(value: T, id: Id) -> serde_json::Result<Vec<u8>>
where
    T: serde::Serialize,
{
    let response = Response::<T, CantSerialize> {
        result: Ok(value),
        id,
    };
    serde_json::to_vec(&response)
}

/// Writes a failed JSON-RPC 2.0 response with the provided error and ID to a vector of bytes.
pub fn write_failure<E>(
    code: impl Into<ErrorCode>,
    message: &str,
    id: Id,
    data: E,
) -> serde_json::Result<Vec<u8>>
where
    E: serde::Serialize,
{
    let response = Response::<CantSerialize, E> {
        result: Err(Error {
            code: code.into(),
            message: Cow::Borrowed(message),
            data: Some(data),
        }),
        id,
    };
    serde_json::to_vec(&response)
}

/// Writes a failed JSON-RPC 2.0 response with the provided error and ID to a vector of bytes.
pub fn write_datalass_failure(
    code: impl Into<ErrorCode>,
    message: &str,
    id: Id,
) -> serde_json::Result<Vec<u8>> {
    let response = Response::<CantSerialize, CantSerialize> {
        result: Err(Error {
            code: code.into(),
            message: Cow::Borrowed(message),
            data: None,
        }),
        id,
    };
    serde_json::to_vec(&response)
}

/// Attmepts to read a request from a slice of bytes.
pub fn read_request<'a, T>(bytes: &'a [u8]) -> serde_json::Result<Request<'a, T>>
where
    T: serde::de::Deserialize<'a>,
{
    serde_json::from_slice(bytes)
}

/// Read a response from a slice of bytes.
pub fn read_response<'a, T, E>(bytes: &'a [u8]) -> serde_json::Result<Response<T, E>>
where
    T: serde::Deserialize<'a>,
    E: serde::Deserialize<'a>,
{
    serde_json::from_slice(bytes)
}

/// Read a response from a slice of bytes, ignoring any potential error data.
pub fn read_response_ignore_error<'a, T>(
    bytes: &'a [u8],
) -> serde_json::Result<Response<T, serde::de::IgnoredAny>>
where
    T: serde::Deserialize<'a>,
{
    serde_json::from_slice(bytes)
}