cord-nvim 2.0.0-beta.28

🚀 The most extensible Discord Rich Presence plugin for Neovim, powered by Rust.
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

#![allow(dead_code)]

use std::collections::HashMap;
use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};

use crate::ipc::pipe::platform::client::PipeClient;
use crate::presence::activity::Activity;
use crate::types::config::PluginConfig;

pub struct Session {
    pub workspace: Option<String>,
    pub timestamp: Option<u64>,
    pub last_activity: Option<Activity>,
    pub last_updated: u128,
    pub config: Option<PluginConfig>,
    pub pipe_client: Option<PipeClient>,
}

impl Session {
    pub fn new() -> Self {
        Self {
            workspace: None,
            timestamp: None,
            last_activity: None,
            last_updated: 0,
            config: None,
            pipe_client: None,
        }
    }

    pub fn set_workspace(&mut self, workspace: String) {
        self.workspace = Some(workspace);
    }

    pub fn set_timestamp(&mut self, timestamp: u64) {
        self.timestamp = Some(timestamp);
    }

    pub fn set_last_activity(&mut self, activity: Activity) {
        self.last_activity = Some(activity);
    }

    pub fn set_config(&mut self, config: PluginConfig) {
        self.config = Some(config);
    }

    pub fn set_pipe_client(&mut self, client: PipeClient) {
        self.pipe_client = Some(client);
    }

    pub fn get_config(&self) -> Option<&PluginConfig> {
        self.config.as_ref()
    }

    pub fn get_config_mut(&mut self) -> Option<&mut PluginConfig> {
        self.config.as_mut()
    }

    pub fn get_pipe_client(&self) -> Option<&PipeClient> {
        self.pipe_client.as_ref()
    }

    pub fn get_pipe_client_mut(&mut self) -> Option<&mut PipeClient> {
        self.pipe_client.as_mut()
    }
}

pub struct SessionRef<'a> {
    sessions: RwLockReadGuard<'a, HashMap<u32, Session>>,
    id: u32,
}

impl std::ops::Deref for SessionRef<'_> {
    type Target = Session;

    fn deref(&self) -> &Self::Target {
        self.sessions.get(&self.id).unwrap()
    }
}

pub struct SessionRefMut<'a> {
    sessions: RwLockWriteGuard<'a, HashMap<u32, Session>>,
    id: u32,
}

impl std::ops::Deref for SessionRefMut<'_> {
    type Target = Session;

    fn deref(&self) -> &Self::Target {
        self.sessions.get(&self.id).unwrap()
    }
}

impl std::ops::DerefMut for SessionRefMut<'_> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.sessions.get_mut(&self.id).unwrap()
    }
}

#[derive(Default)]
pub struct SessionManager {
    pub sessions: RwLock<HashMap<u32, Session>>,
}

impl SessionManager {
    pub fn create_session(&self, id: u32, client: PipeClient) {
        let mut sessions = self.sessions.write().unwrap();
        let mut session = Session::new();
        session.set_pipe_client(client);
        sessions.insert(id, session);
    }

    pub fn remove_session(&self, id: u32) {
        let mut sessions = self.sessions.write().unwrap();
        sessions.remove(&id);
    }

    pub fn get_session(&self, id: u32) -> Option<SessionRef<'_>> {
        let sessions = self.sessions.read().unwrap();
        if sessions.contains_key(&id) {
            Some(SessionRef { sessions, id })
        } else {
            None
        }
    }

    pub fn get_session_mut(&self, id: u32) -> Option<SessionRefMut<'_>> {
        let sessions = self.sessions.write().unwrap();
        if sessions.contains_key(&id) {
            Some(SessionRefMut { sessions, id })
        } else {
            None
        }
    }
}