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
|
use crate::state::channel::{into_channel, Channel};
use crate::state::user::User;
use log::*;
use mumble_protocol::control::msgs;
use serde::{Deserialize, Serialize};
use std::collections::hash_map::Entry;
use std::collections::HashMap;
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Server {
channels: HashMap<u32, Channel>,
users: HashMap<u32, User>,
pub welcome_text: Option<String>,
username: Option<String>,
session_id: Option<u32>,
host: Option<String>,
}
impl Server {
pub fn new() -> Self {
Self {
channels: HashMap::new(),
users: HashMap::new(),
welcome_text: None,
username: None,
session_id: None,
host: None,
}
}
pub fn parse_server_sync(&mut self, mut msg: msgs::ServerSync) {
if msg.has_welcome_text() {
self.welcome_text = Some(msg.take_welcome_text());
}
}
pub fn parse_channel_state(&mut self, msg: msgs::ChannelState) {
if !msg.has_channel_id() {
warn!("Can't parse channel state without channel id");
return;
}
match self.channels.entry(msg.get_channel_id()) {
Entry::Vacant(e) => {
e.insert(Channel::new(msg));
}
Entry::Occupied(mut e) => e.get_mut().parse_channel_state(msg),
}
}
pub fn parse_channel_remove(&mut self, msg: msgs::ChannelRemove) {
if !msg.has_channel_id() {
warn!("Can't parse channel remove without channel id");
return;
}
match self.channels.entry(msg.get_channel_id()) {
Entry::Vacant(_) => {
warn!("Attempted to remove channel that doesn't exist");
}
Entry::Occupied(e) => {
e.remove();
}
}
}
pub fn parse_user_state(&mut self, msg: msgs::UserState) {
if !msg.has_session() {
warn!("Can't parse user state without session");
return;
}
match self.users.entry(msg.get_session()) {
Entry::Vacant(e) => {
e.insert(User::new(msg));
}
Entry::Occupied(mut e) => e.get_mut().parse_user_state(msg),
}
}
pub fn channels(&self) -> &HashMap<u32, Channel> {
&self.channels
}
pub fn host_mut(&mut self) -> &mut Option<String> {
&mut self.host
}
pub fn session_id(&self) -> Option<u32> {
self.session_id
}
pub fn session_id_mut(&mut self) -> &mut Option<u32> {
&mut self.session_id
}
pub fn users(&self) -> &HashMap<u32, User> {
&self.users
}
pub fn users_mut(&mut self) -> &mut HashMap<u32, User> {
&mut self.users
}
pub fn username(&self) -> Option<&str> {
self.username.as_ref().map(|e| e.as_str())
}
pub fn username_mut(&mut self) -> &mut Option<String> {
&mut self.username
}
}
impl From<&Server> for mumlib::state::Server {
fn from(server: &Server) -> Self {
mumlib::state::Server {
channels: into_channel(server.channels(), server.users()),
welcome_text: server.welcome_text.clone(),
username: server.username.clone().unwrap(),
host: server.host.as_ref().unwrap().clone(),
}
}
}
|
