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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

mod request;
mod response;

pub use request::*;
pub use response::*;

use crate::StateModification;

pub struct LanguageRpc {
    rpc: crate::DecthingsClientRpc,
}

impl LanguageRpc {
    pub(crate) fn new(rpc: crate::DecthingsClientRpc) -> Self {
        Self { rpc }
    }

    pub async fn start_language_server(
        &self,
        params: StartLanguageServerParams<'_>,
    ) -> Result<StartLanguageServerResult, crate::DecthingsRpcError<StartLanguageServerError>> {
        let (tx, rx) = tokio::sync::oneshot::channel();
        self.rpc
            .raw_method_call::<_, _, &[u8]>(
                "Language",
                "startLanguageServer",
                params,
                &[],
                crate::RpcProtocol::Ws,
                move |x| {
                    match x {
                        Ok(val) => {
                            let res: Result<
                                super::Response<
                                    StartLanguageServerResult,
                                    StartLanguageServerError,
                                >,
                                crate::DecthingsRpcError<StartLanguageServerError>,
                            > = serde_json::from_slice(&val.0).map_err(Into::into);
                            match res {
                                Ok(super::Response::Result(val)) => {
                                    let language_server_id = val.language_server_id.clone();
                                    tx.send(Ok(val)).ok();
                                    return StateModification {
                                        add_events: vec![language_server_id],
                                        remove_events: vec![],
                                    };
                                }
                                Ok(super::Response::Error(val)) => {
                                    tx.send(Err(crate::DecthingsRpcError::Rpc(val))).ok();
                                }
                                Err(e) => {
                                    tx.send(Err(e)).ok();
                                }
                            }
                        }
                        Err(err) => {
                            tx.send(Err(err.into())).ok();
                        }
                    }
                    StateModification::empty()
                },
            )
            .await;
        rx.await.unwrap()
    }

    pub async fn write_to_language_server(
        &self,
        params: WriteToLanguageServerParams<'_>,
    ) -> Result<WriteToLanguageServerResult, crate::DecthingsRpcError<WriteToLanguageServerError>>
    {
        let (tx, rx) = tokio::sync::oneshot::channel();
        let did_call = self
            .rpc
            .raw_method_call(
                "Language",
                "writeToLanguageServer",
                &params,
                [params.data],
                crate::RpcProtocol::WsIfAvailableOtherwiseNone,
                |x| {
                    tx.send(x).ok();
                    StateModification::empty()
                },
            )
            .await;
        if !did_call {
            return Err(crate::DecthingsRpcError::Rpc(
                WriteToLanguageServerError::LanguageServerNotFound,
            ));
        }
        rx.await
            .unwrap()
            .map_err(crate::DecthingsRpcError::Request)
            .and_then(|x| {
                let res: super::Response<WriteToLanguageServerResult, WriteToLanguageServerError> =
                    serde_json::from_slice(&x.0)?;
                match res {
                    super::Response::Result(val) => Ok(val),
                    super::Response::Error(val) => Err(crate::DecthingsRpcError::Rpc(val)),
                }
            })
    }

    pub async fn unsubscribe_from_events(
        &self,
        params: LanguageUnsubscribeFromEventsParams<'_>,
    ) -> Result<
        LanguageUnsubscribeFromEventsResult,
        crate::DecthingsRpcError<LanguageUnsubscribeFromEventsError>,
    > {
        let (tx, rx) = tokio::sync::oneshot::channel();
        let language_server_id_owned = params.language_server_id.to_owned();
        let did_call = self
            .rpc
            .raw_method_call::<_, _, &[u8]>(
                "Language",
                "unsubscribeFromEvents",
                params,
                &[],
                crate::RpcProtocol::WsIfAvailableOtherwiseNone,
                move |x| {
                    match x {
                        Ok(val) => {
                            let res: Result<
                                super::Response<
                                    LanguageUnsubscribeFromEventsResult,
                                    LanguageUnsubscribeFromEventsError,
                                >,
                                crate::DecthingsRpcError<LanguageUnsubscribeFromEventsError>,
                            > = serde_json::from_slice(&val.0).map_err(Into::into);
                            match res {
                                Ok(super::Response::Result(val)) => {
                                    tx.send(Ok(val)).ok();
                                    return StateModification {
                                        add_events: vec![],
                                        remove_events: vec![language_server_id_owned],
                                    };
                                }
                                Ok(super::Response::Error(val)) => {
                                    tx.send(Err(crate::DecthingsRpcError::Rpc(val))).ok();
                                }
                                Err(e) => {
                                    tx.send(Err(e)).ok();
                                }
                            }
                        }
                        Err(err) => {
                            tx.send(Err(err.into())).ok();
                        }
                    }
                    StateModification::empty()
                },
            )
            .await;
        if !did_call {
            return Err(crate::DecthingsRpcError::Rpc(
                LanguageUnsubscribeFromEventsError::NotSubscribed,
            ));
        }
        rx.await.unwrap()
    }
}