decthings_api/client/rpc/language/
mod.rs

1mod request;
2mod response;
3
4use crate::client::StateModification;
5
6pub use request::*;
7pub use response::*;
8
9pub struct LanguageRpc {
10    rpc: crate::client::DecthingsClientRpc,
11}
12
13impl LanguageRpc {
14    pub(crate) fn new(rpc: crate::client::DecthingsClientRpc) -> Self {
15        Self { rpc }
16    }
17
18    pub async fn start_language_server(
19        &self,
20        params: StartLanguageServerParams<'_>,
21    ) -> Result<StartLanguageServerResult, crate::client::DecthingsRpcError<StartLanguageServerError>>
22    {
23        let (tx, rx) = tokio::sync::oneshot::channel();
24        self.rpc
25            .raw_method_call::<_, _, &[u8]>(
26                "Language",
27                "startLanguageServer",
28                params,
29                &[],
30                crate::client::RpcProtocol::Ws,
31                move |x| {
32                    match x {
33                        Ok(val) => {
34                            let res: Result<
35                                super::Response<
36                                    StartLanguageServerResult,
37                                    StartLanguageServerError,
38                                >,
39                                crate::client::DecthingsRpcError<StartLanguageServerError>,
40                            > = serde_json::from_slice(&val.0).map_err(Into::into);
41                            match res {
42                                Ok(super::Response::Result(val)) => {
43                                    let language_server_id = val.language_server_id.clone();
44                                    tx.send(Ok(val)).ok();
45                                    return StateModification {
46                                        add_events: vec![language_server_id],
47                                        remove_events: vec![],
48                                    };
49                                }
50                                Ok(super::Response::Error(val)) => {
51                                    tx.send(Err(crate::client::DecthingsRpcError::Rpc(val)))
52                                        .ok();
53                                }
54                                Err(e) => {
55                                    tx.send(Err(e)).ok();
56                                }
57                            }
58                        }
59                        Err(err) => {
60                            tx.send(Err(err.into())).ok();
61                        }
62                    }
63                    StateModification::empty()
64                },
65            )
66            .await;
67        rx.await.unwrap()
68    }
69
70    pub async fn write_to_language_server(
71        &self,
72        params: WriteToLanguageServerParams<'_, impl AsRef<[u8]>>,
73    ) -> Result<
74        WriteToLanguageServerResult,
75        crate::client::DecthingsRpcError<WriteToLanguageServerError>,
76    > {
77        let (tx, rx) = tokio::sync::oneshot::channel();
78        let did_call = self
79            .rpc
80            .raw_method_call(
81                "Language",
82                "writeToLanguageServer",
83                &params,
84                [params.data.as_ref()],
85                crate::client::RpcProtocol::WsIfAvailableOtherwiseNone,
86                |x| {
87                    tx.send(x).ok();
88                    StateModification::empty()
89                },
90            )
91            .await;
92        if !did_call {
93            return Err(crate::client::DecthingsRpcError::Rpc(
94                WriteToLanguageServerError::LanguageServerNotFound,
95            ));
96        }
97        rx.await
98            .unwrap()
99            .map_err(crate::client::DecthingsRpcError::Request)
100            .and_then(|x| {
101                let res: super::Response<WriteToLanguageServerResult, WriteToLanguageServerError> =
102                    serde_json::from_slice(&x.0)?;
103                match res {
104                    super::Response::Result(val) => Ok(val),
105                    super::Response::Error(val) => Err(crate::client::DecthingsRpcError::Rpc(val)),
106                }
107            })
108    }
109
110    pub async fn unsubscribe_from_events(
111        &self,
112        params: LanguageUnsubscribeFromEventsParams<'_>,
113    ) -> Result<
114        LanguageUnsubscribeFromEventsResult,
115        crate::client::DecthingsRpcError<LanguageUnsubscribeFromEventsError>,
116    > {
117        let (tx, rx) = tokio::sync::oneshot::channel();
118        let language_server_id_owned = params.language_server_id.to_owned();
119        let did_call = self
120            .rpc
121            .raw_method_call::<_, _, &[u8]>(
122                "Language",
123                "unsubscribeFromEvents",
124                params,
125                &[],
126                crate::client::RpcProtocol::WsIfAvailableOtherwiseNone,
127                move |x| {
128                    match x {
129                        Ok(val) => {
130                            let res: Result<
131                                super::Response<
132                                    LanguageUnsubscribeFromEventsResult,
133                                    LanguageUnsubscribeFromEventsError,
134                                >,
135                                crate::client::DecthingsRpcError<
136                                    LanguageUnsubscribeFromEventsError,
137                                >,
138                            > = serde_json::from_slice(&val.0).map_err(Into::into);
139                            match res {
140                                Ok(super::Response::Result(val)) => {
141                                    tx.send(Ok(val)).ok();
142                                    return StateModification {
143                                        add_events: vec![],
144                                        remove_events: vec![language_server_id_owned],
145                                    };
146                                }
147                                Ok(super::Response::Error(val)) => {
148                                    tx.send(Err(crate::client::DecthingsRpcError::Rpc(val)))
149                                        .ok();
150                                }
151                                Err(e) => {
152                                    tx.send(Err(e)).ok();
153                                }
154                            }
155                        }
156                        Err(err) => {
157                            tx.send(Err(err.into())).ok();
158                        }
159                    }
160                    StateModification::empty()
161                },
162            )
163            .await;
164        if !did_call {
165            return Err(crate::client::DecthingsRpcError::Rpc(
166                LanguageUnsubscribeFromEventsError::NotSubscribed,
167            ));
168        }
169        rx.await.unwrap()
170    }
171}
decthings_api/client/rpc/language/mod.rs

decthings_api/client/rpc/language/
mod.rs
