qlue-ls 3.0.1

A language server for SPARQL
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

use crate::server::{
    configuration::BackendConfiguration,
    lsp::{
        LspMessage,
        errors::{ErrorCode, LSPError},
        rpc::{RequestId, RequestMessageBase, ResponseMessageBase},
    },
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, PartialEq)]
pub struct GetBackendRequest {
    #[serde(flatten)]
    pub base: RequestMessageBase,
    #[serde(default)]
    pub params: GetBackendParams,
}

#[derive(Debug, Default, Deserialize, PartialEq)]
pub struct GetBackendParams {
    pub backend: Option<String>,
}

impl GetBackendRequest {
    pub fn get_id(&self) -> &RequestId {
        &self.base.id
    }
}

impl LspMessage for GetBackendRequest {}

#[derive(Debug, Serialize, PartialEq)]
pub struct GetBackendResponse {
    #[serde(flatten)]
    pub base: ResponseMessageBase,
    pub result: Option<BackendConfiguration>,
    pub error: Option<GetBackendError>,
}

impl GetBackendResponse {
    pub(crate) fn new(
        id: &RequestId,
        backend: Option<&BackendConfiguration>,
        error_message: &str,
    ) -> Self {
        if let Some(backend) = backend {
            Self {
                base: ResponseMessageBase::success(id),
                result: Some(backend.clone()),
                error: None,
            }
        } else {
            Self {
                base: ResponseMessageBase::success(id),
                result: None,
                error: Some(LSPError {
                    code: ErrorCode::InvalidParams,
                    message: error_message.to_string(),
                    data: None,
                }),
            }
        }
    }
}

impl LspMessage for GetBackendResponse {}

pub type GetBackendError = LSPError;