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
|
use crate::error::ProtocolError;
use crate::message::MessageType;
use crate::primitive::{Variant, VariantList};
use crate::serialize::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum Class {
AliasManager,
BacklogManager,
BufferSyncer,
BufferViewConfig,
BufferViewManager,
CoreInfo,
CoreData,
HighlightRuleManager,
Identity,
IgnoreListManager,
CertManager,
Network,
NetworkInfo,
NetworkConfig,
IrcChannel,
IrcUser,
Unknown,
}
impl From<String> for Class {
fn from(class: String) -> Self {
Self::from(class.as_str())
}
}
impl From<&str> for Class {
fn from(class: &str) -> Self {
match class {
"AliasManager" => Self::AliasManager,
"BacklogManager" => Class::BacklogManager,
"BufferSyncer" => Self::BufferSyncer,
"BufferViewConfig" => Self::BufferViewConfig,
"BufferViewManager" => Self::BufferViewManager,
"CoreInfo" => Self::CoreInfo,
"CoreData" => Self::CoreData,
"HighlightRuleManager" => Self::HighlightRuleManager,
"Identity" => Self::Identity,
"IgnoreListManager" => Self::IgnoreListManager,
"CertManager" => Self::CertManager,
"Network" => Self::Network,
"NetworkInfo" => Self::NetworkInfo,
"NetworkConfig" => Self::NetworkConfig,
"IrcChannel" => Self::IrcChannel,
"IrcUser" => Self::IrcUser,
_ => Self::Unknown,
}
}
}
impl Class {
pub fn as_str(&self) -> &str {
match self {
Class::AliasManager => "AliasManager",
Class::BacklogManager => "BacklogManager",
Class::BufferSyncer => "BufferSyncer",
Class::BufferViewConfig => "BufferViewConfig",
Class::BufferViewManager => "BufferViewManager",
Class::CoreInfo => "CoreInfo",
Class::CoreData => "CoreData",
Class::HighlightRuleManager => "HighlightRuleManager",
Class::Identity => "Identity",
Class::IgnoreListManager => "IgnoreListManager",
Class::CertManager => "CertManager",
Class::Network => "Network",
Class::NetworkInfo => "NetworkInfo",
Class::NetworkConfig => "NetworkConfig",
Class::IrcChannel => "IrcChannel",
Class::IrcUser => "IrcUser",
Class::Unknown => "Unknown",
}
}
}
#[derive(Clone, Debug, std::cmp::PartialEq)]
pub struct SyncMessage {
pub class_name: Class,
pub object_name: String,
pub slot_name: String,
pub params: VariantList,
}
// impl Act for SyncMessage {}
impl Serialize for SyncMessage {
fn serialize(&self) -> Result<Vec<std::primitive::u8>, ProtocolError> {
let mut res = VariantList::new();
res.push(Variant::i32(MessageType::SyncMessage as i32));
res.push(Variant::ByteArray(self.class_name.as_str().to_owned()));
res.push(Variant::ByteArray(self.object_name.clone()));
res.push(Variant::ByteArray(self.slot_name.clone()));
res.append(&mut self.params.clone());
res.serialize()
}
}
impl Deserialize for SyncMessage {
fn parse(b: &[std::primitive::u8]) -> Result<(std::primitive::usize, Self), ProtocolError> {
let (size, mut res) = VariantList::parse(b)?;
res.remove(0);
let class_name: String = res.remove(0).try_into().unwrap();
Ok((
size,
Self {
class_name: Class::from(class_name),
object_name: res.remove(0).try_into().unwrap(),
slot_name: res.remove(0).try_into().unwrap(),
params: res,
},
))
}
}
|
