gveditor_core_api/extensions/
client.rs

1use std::collections::HashMap;
2use std::path::PathBuf;
3use std::sync::{Arc, Mutex};
4use tokio::sync::mpsc::error::SendError;
5
6use crate::messaging::Messages;
7use crate::tokio::sync::mpsc::Sender as AsyncSender;
8use crate::LanguageServer;
9
10use super::settings::ExtensionSettings;
11
12#[derive(Clone)]
13pub struct ExtensionClient {
14    extension_id: String,
15    name: String,
16    id_count: Arc<Mutex<i32>>,
17    sender: AsyncSender<Messages>,
18    #[allow(dead_code)]
19    settings_path: Option<PathBuf>,
20}
21
22impl ExtensionClient {
23    pub fn new(
24        extension_id: &str,
25        name: &str,
26        sender: AsyncSender<Messages>,
27        settings_path: Option<PathBuf>,
28    ) -> Self {
29        Self {
30            extension_id: extension_id.to_string(),
31            name: name.to_string(),
32            id_count: Arc::new(Mutex::new(0)),
33            sender,
34            settings_path: settings_path.map(|path| path.join(extension_id)),
35        }
36    }
37
38    pub fn get_id(&mut self) -> String {
39        *self.id_count.lock().unwrap() += 1;
40        format!("{}/{}", self.name, self.id_count.lock().unwrap())
41    }
42
43    pub async fn send(&self, message: Messages) -> Result<(), SendError<Messages>> {
44        self.sender.send(message).await
45    }
46
47    pub async fn register_language_server(
48        &self,
49        state_id: u8,
50        languages: HashMap<String, LanguageServer>,
51    ) -> Result<(), SendError<Messages>> {
52        self.sender
53            .send(Messages::RegisterLanguageServers {
54                state_id,
55                languages,
56                extension_id: self.extension_id.clone(),
57            })
58            .await
59    }
60
61    #[allow(dead_code)]
62    pub async fn get_settings(&self) -> Option<ExtensionSettings> {
63        let path = self.settings_path.as_ref()?;
64        Some(ExtensionSettings::new(path.clone()).await)
65    }
66}