rework Network derives to be more consistent

i don't even know anymore, blame past me

15 files changed, 147 insertions, 362 deletions

diff --git a/src/message/signalproxy/objects/aliasmanager.rs b/src/message/signalproxy/objects/aliasmanager.rs
index 489d8c8..6d6b63c 100644
--- a/src/message/signalproxy/objects/aliasmanager.rs
+++ b/src/message/signalproxy/objects/aliasmanager.rs
@@ -10,8 +10,6 @@ use crate::message::StatefulSyncableServer;
 
 use crate::message::Syncable;
 
-use crate::message::signalproxy::translation::NetworkMap;
-
 #[allow(unused_imports)]
 use crate::primitive::VariantMap;
 
@@ -20,7 +18,7 @@ use crate::primitive::VariantMap;
 /// syncable
 #[derive(Clone, Default, Debug, std::cmp::PartialEq, NetworkList, NetworkMap)]
 pub struct AliasManager {
-    #[network(rename = "Aliases", variant = "VariantMap", network, map)]
+    #[network(rename = "Aliases", variant = "VariantMap", network = "map")]
     pub aliases: Vec<Alias>,
 }
 
diff --git a/src/message/signalproxy/objects/buffersyncer.rs b/src/message/signalproxy/objects/buffersyncer.rs
index 9bca521..f085423 100644
--- a/src/message/signalproxy/objects/buffersyncer.rs
+++ b/src/message/signalproxy/objects/buffersyncer.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
-    message::{signalproxy::translation::Network, Syncable, Class},
+    message::{Syncable, Class},
     primitive::MessageType,
 };
 
@@ -9,13 +9,13 @@ use libquassel_derive::{sync, NetworkList, NetworkMap};
 
 #[derive(Default, Debug, Clone, PartialEq, NetworkList, NetworkMap)]
 pub struct BufferSyncer {
-    #[network(rename = "Activities", network, variant = "VariantList")]
+    #[network(rename = "Activities", network = "list", variant = "VariantList")]
     pub activities: HashMap<i32, MessageType>,
-    #[network(rename = "HighlightCounts", network, variant = "VariantList")]
+    #[network(rename = "HighlightCounts", network = "list", variant = "VariantList")]
     pub highlight_counts: HashMap<i32, i32>,
-    #[network(rename = "LastSeenMsg", network, variant = "VariantList")]
+    #[network(rename = "LastSeenMsg", network = "list", variant = "VariantList")]
     pub last_seen_msg: HashMap<i32, i64>,
-    #[network(rename = "MarkerLines", network, variant = "VariantList")]
+    #[network(rename = "MarkerLines", network = "list", variant = "VariantList")]
     pub marker_line: HashMap<i32, i64>,
 }
 
diff --git a/src/message/signalproxy/objects/bufferviewconfig.rs b/src/message/signalproxy/objects/bufferviewconfig.rs
index cdca0dc..bc60768 100644
--- a/src/message/signalproxy/objects/bufferviewconfig.rs
+++ b/src/message/signalproxy/objects/bufferviewconfig.rs
@@ -1,23 +1,25 @@
 use libquassel_derive::sync;
 use libquassel_derive::{NetworkList, NetworkMap};
 
-use crate::message::signalproxy::translation::Network;
-
 #[allow(unused_imports)]
 use crate::message::StatefulSyncableClient;
 #[allow(unused_imports)]
 use crate::message::StatefulSyncableServer;
-use crate::message::{Syncable, Class};
+use crate::message::{Class, Syncable};
 
 use crate::primitive::VariantList;
 
 #[derive(Debug, Default, Clone, PartialEq, NetworkList, NetworkMap)]
 pub struct BufferViewConfig {
-    #[network(rename = "BufferList", network, variant = "VariantList")]
+    #[network(rename = "BufferList", network = "map", variant = "VariantList")]
     pub buffers: Vec<i32>,
-    #[network(rename = "RemovedBuffers", network, variant = "VariantList")]
+    #[network(rename = "RemovedBuffers", network = "map", variant = "VariantList")]
     pub removed_buffers: Vec<i32>,
-    #[network(rename = "TemporarilyRemovedBuffers", network, variant = "VariantList")]
+    #[network(
+        rename = "TemporarilyRemovedBuffers",
+        network = "map",
+        variant = "VariantList"
+    )]
     pub temporarily_removed_buffers: Vec<i32>,
 
     #[network(rename = "bufferViewId", default, skip)]
diff --git a/src/message/signalproxy/objects/coreinfo.rs b/src/message/signalproxy/objects/coreinfo.rs
index 9bfa728..7b3009a 100644
--- a/src/message/signalproxy/objects/coreinfo.rs
+++ b/src/message/signalproxy/objects/coreinfo.rs
@@ -7,7 +7,7 @@ use crate::primitive::{DateTime, StringList};
 #[derive(Default, Debug, Clone, PartialEq, NetworkList, NetworkMap)]
 #[network(repr = "map")]
 pub struct CoreInfo {
-    #[network(rename = "coreData", variant = "VariantMap", network)]
+    #[network(rename = "coreData", variant = "VariantMap", network = "map")]
     pub core_data: CoreData,
 }
 
@@ -68,8 +68,7 @@ pub struct CoreData {
     #[network(
         rename = "sessionConnectedClientData",
         variant = "VariantList",
-        network,
-        map
+        network = "map",
     )]
     pub session_connected_client_data: Vec<ConnectedClient>,
 }
diff --git a/src/message/signalproxy/objects/highlightrulemanager.rs b/src/message/signalproxy/objects/highlightrulemanager.rs
index b054403..1a2b58f 100644
--- a/src/message/signalproxy/objects/highlightrulemanager.rs
+++ b/src/message/signalproxy/objects/highlightrulemanager.rs
@@ -1,11 +1,6 @@
-use libquassel_derive::sync;
-use num_derive::{FromPrimitive, ToPrimitive};
-use num_traits::{FromPrimitive, ToPrimitive};
-
-use libquassel_derive::{NetworkList, NetworkMap};
+use libquassel_derive::{sync, NetworkList, NetworkMap};
 
 use crate::message::Class;
-use crate::message::signalproxy::translation::{Network, NetworkMap};
 
 #[allow(unused_imports)]
 use crate::message::StatefulSyncableClient;
@@ -13,12 +8,13 @@ use crate::message::StatefulSyncableClient;
 use crate::message::StatefulSyncableServer;
 
 use crate::message::Syncable;
+use crate::primitive::Variant;
 
 #[derive(Default, Debug, Clone, PartialEq, NetworkList, NetworkMap)]
 pub struct HighlightRuleManager {
-    #[network(rename = "HighlightRuleList", variant = "VariantMap", network, map)]
+    #[network(rename = "HighlightRuleList", variant = "VariantMap", network = "map")]
     pub highlight_rule_list: Vec<HighlightRule>,
-    #[network(rename = "highlightNick", variant = "i32", network)]
+    #[network(rename = "highlightNick", type = "i32")]
     pub highlight_nick: HighlightNickType,
     #[network(rename = "nicksCaseSensitive")]
     pub nicks_case_sensitive: bool,
@@ -86,7 +82,7 @@ impl HighlightRuleManager {
     }
 
     pub fn request_set_highlight_nick(&self, nick: HighlightNickType) {
-        sync!("requestSetHighlightNick", [nick.to_network()])
+        sync!("requestSetHighlightNick", [nick])
     }
 
     pub fn request_set_nicks_case_sensitive(&self, enabled: bool) {
@@ -168,9 +164,7 @@ impl StatefulSyncableClient for HighlightRuleManager {
                 sender: get_param!(msg),
                 channel: get_param!(msg),
             }),
-            "setHighlightNick" => {
-                self.set_highlight_nick(HighlightNickType::from_network(&mut get_param!(msg)))
-            }
+            "setHighlightNick" => self.set_highlight_nick(get_param!(msg)),
             "setNicksCaseSensitive" => self.set_nicks_case_sensitive(get_param!(msg)),
             _ => (),
         }
@@ -196,9 +190,7 @@ impl StatefulSyncableServer for HighlightRuleManager {
                 sender: get_param!(msg),
                 channel: get_param!(msg),
             }),
-            "requestSetHighlightNick" => {
-                self.set_highlight_nick(HighlightNickType::from_network(&mut get_param!(msg)))
-            }
+            "requestSetHighlightNick" => self.set_highlight_nick(get_param!(msg)),
             "requestSetNicksCaseSensitive" => self.set_nicks_case_sensitive(get_param!(msg)),
             _ => (),
         }
@@ -229,7 +221,7 @@ pub struct HighlightRule {
     pub channel: String,
 }
 
-#[derive(Default, Debug, Clone, PartialEq, FromPrimitive, ToPrimitive)]
+#[derive(Default, Debug, Clone, PartialEq)]
 pub enum HighlightNickType {
     #[default]
     NoNick = 0x00,
@@ -237,15 +229,34 @@ pub enum HighlightNickType {
     AllNicks = 0x02,
 }
 
-impl crate::message::signalproxy::Network for HighlightNickType {
-    type Item = i32;
+impl From<HighlightNickType> for Variant {
+    fn from(value: HighlightNickType) -> Self {
+        Variant::i32(value as i32)
+    }
+}
 
-    fn to_network(&self) -> Self::Item {
-        self.to_i32().unwrap()
+impl From<Variant> for HighlightNickType {
+    fn from(value: Variant) -> Self {
+        HighlightNickType::try_from(value).unwrap()
     }
+}
 
-    fn from_network(input: &mut Self::Item) -> Self {
-        Self::from_i32(*input).unwrap()
+impl From<HighlightNickType> for i32 {
+    fn from(value: HighlightNickType) -> Self {
+        value as i32
+    }
+}
+
+impl TryFrom<i32> for HighlightNickType {
+    type Error = &'static str;
+
+    fn try_from(value: i32) -> Result<Self, Self::Error> {
+        match value {
+            0x00 => Ok(HighlightNickType::NoNick),
+            0x01 => Ok(HighlightNickType::CurrentNick),
+            0x02 => Ok(HighlightNickType::AllNicks),
+            _ => Err("no matching HighlightNickType found"),
+        }
     }
 }
 
diff --git a/src/message/signalproxy/objects/ignorelistmanager.rs b/src/message/signalproxy/objects/ignorelistmanager.rs
index 1d04f98..7050bdd 100644
--- a/src/message/signalproxy/objects/ignorelistmanager.rs
+++ b/src/message/signalproxy/objects/ignorelistmanager.rs
@@ -1,14 +1,14 @@
-use crate::{message::{
-    signalproxy::translation::{Network, NetworkMap, NetworkList},
-    Syncable, Class,
-}, primitive::Variant};
+use crate::{
+    message::{Class, Syncable},
+    primitive::Variant,
+};
 
 use libquassel_derive::{sync, NetworkList, NetworkMap};
 
 #[derive(Default, Debug, Clone, PartialEq, NetworkList, NetworkMap)]
 pub struct IgnoreListManager {
     #[quassel(name = "IgnoreList")]
-    #[network(variant = "VariantMap", network, map)]
+    #[network(variant = "VariantMap", network = "map")]
     pub ignore_list: Vec<IgnoreListItem>,
 }
 
diff --git a/src/message/signalproxy/objects/ircchannel.rs b/src/message/signalproxy/objects/ircchannel.rs
index bbdc600..105f318 100644
--- a/src/message/signalproxy/objects/ircchannel.rs
+++ b/src/message/signalproxy/objects/ircchannel.rs
@@ -2,38 +2,24 @@ use std::collections::HashMap;
 
 #[cfg(feature = "server")]
 use libquassel_derive::sync;
-use libquassel_derive::Setters;
+use libquassel_derive::{NetworkMap, Setters};
 use log::{error, warn};
 
-use crate::message::{NetworkMap, Syncable, Class};
-use crate::primitive::{StringList, Variant, VariantList, VariantMap};
+use crate::message::{Class, Syncable};
+use crate::primitive::StringList;
 
-use super::ChannelModeType;
+use super::{ChanModes, ChannelModeType};
 
 #[allow(dead_code)]
-#[derive(Debug, Clone, PartialEq, Setters)]
+#[derive(Debug, Clone, PartialEq, Setters, NetworkMap)]
+#[network(repr = "maplist")]
 pub struct IrcChannel {
-    /// Modes that add or remove items from a list, like commonly +b for the banlist.
-    ///
-    /// Always require a parameter from server to client.
-    /// Clients can request the whole list by leaving the parameter empty
-    #[setter(skip)]
-    pub channel_modes_a: HashMap<char, StringList>,
-
-    /// Modes that take a parameter as setting and require it when setting or removing the mode.
-    #[setter(skip)]
-    pub channel_modes_b: HashMap<char, String>,
-
-    /// Modes that take a parameter as setting, but only require it when setting the mode.
-    #[setter(skip)]
-    pub channel_modes_c: HashMap<char, String>,
-
-    /// Modes without a parameter.
-    #[setter(skip)]
-    pub channel_modes_d: String,
+    #[network(rename = "ChanModes", network = "map")]
+    pub chan_modes: ChanModes,
 
     // pub channel_modes: HashMap<char, ChannelMode>,
     #[setter(skip)]
+    #[network(rename = "UserModes", network = "map")]
     pub user_modes: HashMap<String, String>,
     #[setter(skip)]
     pub name: String,
@@ -49,38 +35,43 @@ impl IrcChannel {
         match mode_type {
             ChannelModeType::NotAChanmode => (),
             ChannelModeType::AChanmode => {
-                self.channel_modes_a.insert(mode, vec![value]);
-            },
+                self.chan_modes.channel_modes_a.insert(mode, vec![value]);
+            }
             ChannelModeType::BChanmode => {
-                self.channel_modes_b.insert(mode, value);
-            },
+                self.chan_modes.channel_modes_b.insert(mode, value);
+            }
             ChannelModeType::CChanmode => {
-                self.channel_modes_c.insert(mode, value);
-            },
+                self.chan_modes.channel_modes_c.insert(mode, value);
+            }
             ChannelModeType::DChanmode => {
-                if ! self.channel_modes_d.contains(mode) {
-                    self.channel_modes_d.push(mode);
+                if !self.chan_modes.channel_modes_d.contains(mode) {
+                    self.chan_modes.channel_modes_d.push(mode);
                 };
-            },
+            }
         };
     }
     pub fn remove_channel_mode(&mut self, mode_type: ChannelModeType, mode: char, value: String) {
         match mode_type {
             ChannelModeType::NotAChanmode => (),
             ChannelModeType::AChanmode => {
-                self.channel_modes_a.remove(&mode);
-            },
+                self.chan_modes.channel_modes_a.remove(&mode);
+            }
             ChannelModeType::BChanmode => {
-                self.channel_modes_b.remove(&mode);
-            },
+                self.chan_modes.channel_modes_b.remove(&mode);
+            }
             ChannelModeType::CChanmode => {
-                self.channel_modes_c.remove(&mode);
-            },
+                self.chan_modes.channel_modes_c.remove(&mode);
+            }
             ChannelModeType::DChanmode => {
-                if self.channel_modes_d.contains(mode) {
-                    self.channel_modes_d = self.channel_modes_d.chars().filter(|c| *c != mode).collect();
+                if self.chan_modes.channel_modes_d.contains(mode) {
+                    self.chan_modes.channel_modes_d = self
+                        .chan_modes
+                        .channel_modes_d
+                        .chars()
+                        .filter(|c| *c != mode)
+                        .collect();
                 };
-            },
+            }
         }
     }
 
@@ -206,242 +197,28 @@ impl Syncable for IrcChannel {
     const CLASS: Class = Class::IrcChannel;
 }
 
-impl NetworkMap for Vec<IrcChannel> {
-    type Item = VariantMap;
-
-    fn to_network_map(&self) -> Self::Item {
-        let mut channelmodes: VariantList = Vec::with_capacity(self.len());
-        let mut usermodes: VariantList = Vec::with_capacity(self.len());
-        let mut name: VariantList = Vec::with_capacity(self.len());
-        let mut topic: VariantList = Vec::with_capacity(self.len());
-        let mut password: VariantList = Vec::with_capacity(self.len());
-        let mut encrypted: VariantList = Vec::with_capacity(self.len());
-
-        let mut map = VariantMap::new();
-
-        self.iter().for_each(|item| {
-            channelmodes.push(Variant::VariantMap({
-                let mut map = VariantMap::new();
-
-                map.insert(
-                    s!("A"),
-                    Variant::VariantMap(
-                        item.channel_modes_a
-                            .iter()
-                            .map(|(k, v)| (k.to_string(), Variant::StringList(v.clone())))
-                            .collect(),
-                    ),
-                );
-                map.insert(
-                    s!("B"),
-                    Variant::VariantMap(
-                        item.channel_modes_b
-                            .iter()
-                            .map(|(k, v)| (k.to_string(), Variant::String(v.clone())))
-                            .collect(),
-                    ),
-                );
-                map.insert(
-                    s!("C"),
-                    Variant::VariantMap(
-                        item.channel_modes_c
-                            .iter()
-                            .map(|(k, v)| (k.to_string(), Variant::String(v.clone())))
-                            .collect(),
-                    ),
-                );
-                map.insert(s!("D"), Variant::String(item.channel_modes_d.clone()));
-
-                map
-            }));
-
-            usermodes.push(Variant::VariantMap(
-                item.user_modes
-                    .iter()
-                    .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
-                    .collect(),
-            ));
-            name.push(Variant::String(item.name.clone()));
-            topic.push(Variant::String(item.topic.clone()));
-            password.push(Variant::String(item.password.clone()));
-            encrypted.push(Variant::bool(item.encrypted));
-        });
-
-        map.insert(
-            String::from("ChanModes"),
-            Variant::VariantList(channelmodes),
-        );
-        map.insert(String::from("UserModes"), Variant::VariantList(usermodes));
-        map.insert(String::from("name"), Variant::VariantList(name));
-        map.insert(String::from("topic"), Variant::VariantList(topic));
-        map.insert(String::from("password"), Variant::VariantList(password));
-        map.insert(String::from("encrypted"), Variant::VariantList(encrypted));
-
-        map
-    }
-
-    fn from_network_map(input: &mut Self::Item) -> Self {
-        let marker: VariantList =
-            std::convert::TryInto::try_into(input.get("name").unwrap()).unwrap();
-
-        let mut res = Vec::new();
-        for _ in 0..marker.len() {
-            res.push(IrcChannel::from_network_map(input));
-        }
-
-        return res;
-    }
-}
-
-impl NetworkMap for IrcChannel {
-    type Item = VariantMap;
-
-    fn to_network_map(&self) -> Self::Item {
-        let mut res = VariantMap::new();
-
-        res.insert(
-            s!("ChanModes"),
-            Variant::VariantList({
-                let mut map = VariantMap::new();
-
-                map.insert(
-                    s!("A"),
-                    Variant::VariantMap(
-                        self.channel_modes_a
-                            .iter()
-                            .map(|(k, v)| (k.to_string(), Variant::StringList(v.clone())))
-                            .collect(),
-                    ),
-                );
-                map.insert(
-                    s!("B"),
-                    Variant::VariantMap(
-                        self.channel_modes_b
-                            .iter()
-                            .map(|(k, v)| (k.to_string(), Variant::String(v.clone())))
-                            .collect(),
-                    ),
-                );
-                map.insert(
-                    s!("C"),
-                    Variant::VariantMap(
-                        self.channel_modes_c
-                            .iter()
-                            .map(|(k, v)| (k.to_string(), Variant::String(v.clone())))
-                            .collect(),
-                    ),
-                );
-                map.insert(s!("D"), Variant::String(self.channel_modes_d.clone()));
-
-                vec![Variant::VariantMap(map)]
-            }),
-        );
-
-        res.insert(
-            s!("UserModes"),
-            Variant::VariantList(vec![Variant::VariantMap(
-                self.user_modes
-                    .iter()
-                    .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
-                    .collect(),
-            )]),
-        );
-        res.insert(
-            s!("name"),
-            Variant::VariantList(vec![Variant::String(self.name.clone())]),
-        );
-        res.insert(
-            s!("topic"),
-            Variant::VariantList(vec![Variant::String(self.topic.clone())]),
-        );
-        res.insert(
-            s!("password"),
-            Variant::VariantList(vec![Variant::String(self.password.clone())]),
-        );
-        res.insert(
-            s!("encrypted"),
-            Variant::VariantList(vec![Variant::bool(self.encrypted.clone())]),
-        );
-
-        res
-    }
-    fn from_network_map(input: &mut Self::Item) -> Self {
-        let mut chanmodes: VariantMap = match_variant!(
-            match_variant!(input.get_mut("ChanModes").unwrap(), Variant::VariantList).remove(0),
-            Variant::VariantMap
-        );
-
-        Self {
-            channel_modes_a: match_variant!(chanmodes.remove("A").unwrap(), Variant::VariantMap)
-                .into_iter()
-                .map(|(mut k, v)| (k.remove(0), match_variant!(v, Variant::StringList)))
-                .collect(),
-            channel_modes_b: match_variant!(chanmodes.remove("B").unwrap(), Variant::VariantMap)
-                .into_iter()
-                .map(|(mut k, v)| (k.remove(0), match_variant!(v, Variant::String)))
-                .collect(),
-            channel_modes_c: match_variant!(chanmodes.remove("C").unwrap(), Variant::VariantMap)
-                .into_iter()
-                .map(|(mut k, v)| (k.remove(0), match_variant!(v, Variant::String)))
-                .collect(),
-            channel_modes_d: match_variant!(chanmodes.remove("D").unwrap(), Variant::String),
-            user_modes: VariantMap::try_from(
-                match_variant!(input.get_mut("UserModes").unwrap(), Variant::VariantList).remove(0),
-            )
-            .unwrap()
-            .into_iter()
-            .map(|(k, v)| (k, v.try_into().unwrap()))
-            .collect(),
-            name: match_variant!(input.get_mut("name").unwrap(), Variant::VariantList)
-                .remove(0)
-                .try_into()
-                .unwrap(),
-            topic: match_variant!(input.get_mut("topic").unwrap(), Variant::VariantList)
-                .remove(0)
-                .try_into()
-                .unwrap(),
-            password: match_variant!(input.get_mut("password").unwrap(), Variant::VariantList)
-                .remove(0)
-                .try_into()
-                .unwrap(),
-            encrypted: match_variant!(input.get_mut("encrypted").unwrap(), Variant::VariantList)
-                .remove(0)
-                .try_into()
-                .unwrap(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    use crate::primitive::{Variant, VariantMap};
+    use crate::message::NetworkMap;
+
     fn get_network() -> VariantMap {
         map! {
-            s!("encrypted") => Variant::VariantList(
-                vec![
+            s!("encrypted") =>
                     Variant::bool(
                         false,
                     ),
-                ],
-            ),
-            s!("topic") => Variant::VariantList(
-                vec![
+            s!("topic") =>
                     Variant::String(
                         s!(""),
                     ),
-                ],
-            ),
-            s!("password") => Variant::VariantList(
-                vec![
+            s!("password") =>
                     Variant::String(
                         s!(""),
                     ),
-                ],
-            ),
-            s!("ChanModes") => Variant::VariantList(
-                vec![
-                    Variant::VariantMap(map!
+            s!("ChanModes") => Variant::VariantMap(map!
                         {
                             s!("B") => Variant::VariantMap(map!
                                 {},
@@ -470,10 +247,7 @@ mod tests {
                             }),
                         },
                     ),
-                ],
-            ),
-            s!("UserModes") => Variant::VariantList(
-                vec![
+            s!("UserModes") =>
                     Variant::VariantMap(map!
                         {
                             s!("audron") => Variant::String(
@@ -484,23 +258,20 @@ mod tests {
                             ),
                         },
                     ),
-                ],
-            ),
-            s!("name") => Variant::VariantList(
-                vec![
+            s!("name") =>
                     Variant::String(
                         s!("#audron-test"),
                     ),
-                ],
-            )
         }
     }
     fn get_runtime() -> IrcChannel {
         IrcChannel {
-            channel_modes_a: map! { 'b' => vec![s!("*!*@test"), s!("*!*@test2")] },
-            channel_modes_b: map! {},
-            channel_modes_c: map! { 'j' => s!("5:1"), 'x' => s!("10:5"), 'f' => s!("30:5"), 'F' => s!("5:60") },
-            channel_modes_d: s!("tCnT"),
+            chan_modes: ChanModes {
+                channel_modes_a: map! { 'b' => vec![s!("*!*@test"), s!("*!*@test2")] },
+                channel_modes_b: map! {},
+                channel_modes_c: map! { 'j' => s!("5:1"), 'x' => s!("10:5"), 'f' => s!("30:5"), 'F' => s!("5:60") },
+                channel_modes_d: s!("tCnT"),
+            },
             user_modes: map! { s!("audron") => s!("o"), s!("audron_") => s!("") },
             name: s!("#audron-test"),
             topic: s!(""),
diff --git a/src/message/signalproxy/objects/ircuser.rs b/src/message/signalproxy/objects/ircuser.rs
index 833a162..b96ea95 100644
--- a/src/message/signalproxy/objects/ircuser.rs
+++ b/src/message/signalproxy/objects/ircuser.rs
@@ -3,9 +3,6 @@ use crate::{
     primitive::{DateTime, StringList},
 };
 
-#[allow(unused_imports)]
-use crate::message::signalproxy::Network;
-
 use itertools::Itertools;
 #[cfg(feature = "server")]
 use libquassel_derive::sync;
diff --git a/src/message/signalproxy/objects/mod.rs b/src/message/signalproxy/objects/mod.rs
index 5ef746a..de5bf35 100644
--- a/src/message/signalproxy/objects/mod.rs
+++ b/src/message/signalproxy/objects/mod.rs
@@ -9,6 +9,7 @@ mod highlightrulemanager;
 mod identity;
 mod ignorelistmanager;
 mod ircchannel;
+mod chanmodes;
 mod ircuser;
 mod network;
 mod networkinfo;
@@ -24,6 +25,7 @@ pub use highlightrulemanager::*;
 pub use identity::*;
 pub use ignorelistmanager::*;
 pub use ircchannel::*;
+pub use chanmodes::*;
 pub use ircuser::*;
 pub use network::*;
 pub use networkinfo::*;
@@ -68,6 +70,7 @@ pub enum Types {
     Network(network::Network),
     NetworkInfo(NetworkInfo),
     NetworkConfig(NetworkConfig),
+    // IrcChannel(IrcChannel),
     Unknown(VariantList),
 }
 
@@ -87,6 +90,7 @@ impl Types {
             Types::Network(val) => val.to_network_list(),
             Types::NetworkInfo(val) => val.to_network_list(),
             Types::NetworkConfig(val) => val.to_network_list(),
+            // Types::IrcChannel(val) => todo!(),
             Types::Unknown(val) => val.clone(),
         }
     }
@@ -123,6 +127,7 @@ impl Types {
             "Network" => Types::Network(Network::from_network_list(input)),
             "NetworkInfo" => Types::NetworkInfo(NetworkInfo::from_network_list(input)),
             "NetworkConfig" => Types::NetworkConfig(NetworkConfig::from_network_list(input)),
+            // "IrcChannel" => Types::IrcChannel(IrcChannel::from_network_list(input)),
             _ => Types::Unknown(input.to_owned()),
         }
     }
diff --git a/src/message/signalproxy/objects/networkinfo.rs b/src/message/signalproxy/objects/networkinfo.rs
index b304ed1..d11b7c8 100644
--- a/src/message/signalproxy/objects/networkinfo.rs
+++ b/src/message/signalproxy/objects/networkinfo.rs
@@ -3,14 +3,13 @@ use crate::primitive::StringList;
 use libquassel_derive::NetworkList;
 
 use crate::message::objects::network::NetworkServer;
-use crate::message::signalproxy::translation::NetworkMap;
 
 #[derive(Default, Debug, Clone, PartialEq, NetworkList)]
 pub struct NetworkInfo {
     #[network(rename = "networkName")]
     pub network_name: String,
 
-    #[network(rename = "ServerList", variant = "VariantList", network, map)]
+    #[network(rename = "ServerList", variant = "VariantList", network = "map")]
     pub server_list: Vec<NetworkServer>,
     #[network(rename = "perform")]
     pub perform: StringList,
diff --git a/src/message/signalproxy/translation/mod.rs b/src/message/signalproxy/translation/mod.rs
index ae1adce..a55d6f3 100644
--- a/src/message/signalproxy/translation/mod.rs
+++ b/src/message/signalproxy/translation/mod.rs
@@ -86,6 +86,7 @@ VariantMap({
 **/
 use crate::primitive::{Variant, VariantList};
 
+#[deprecated(since="0.1.0", note="please use NetworkMap and NetworkList implementations")]
 pub trait Network {
     type Item;
 
diff --git a/src/primitive/message.rs b/src/primitive/message.rs
index ff992e3..12edb29 100644
--- a/src/primitive/message.rs
+++ b/src/primitive/message.rs
@@ -6,7 +6,7 @@ use crate::{deserialize::*, serialize::*};
 
 use crate::primitive::BufferInfo;
 
-use super::Variant;
+use super::{Variant, VariantList};
 
 /// The Message struct represents a Message as received in IRC
 ///
@@ -222,13 +222,11 @@ bitflags! {
     }
 }
 
-impl<T> crate::message::Network for HashMap<T, MessageType>
+impl<T> crate::message::NetworkList for HashMap<T, MessageType>
 where
     T: std::convert::TryFrom<Variant> + Into<Variant> + Clone + std::hash::Hash + std::cmp::Eq,
 {
-    type Item = super::VariantList;
-
-    fn to_network(&self) -> Self::Item {
+    fn to_network_list(&self) -> VariantList {
         let mut res = Vec::with_capacity(self.len() * 2);
 
         self.iter().for_each(|(k, v)| {
@@ -239,7 +237,7 @@ where
         return res;
     }
 
-    fn from_network(input: &mut Self::Item) -> Self {
+    fn from_network_list(input: &mut VariantList) -> Self {
         use itertools::Itertools;
 
         let mut res = HashMap::with_capacity(input.len() / 2);
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index 673d39f..b306ea7 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -86,38 +86,12 @@ impl From<&str> for Variant {
 
 /// Implements the Network trait genericly for everything that
 /// can be a VariantList / Vec<T>
-impl<T> crate::message::Network for Vec<T>
-where
-    T: std::convert::TryFrom<Variant> + Into<Variant> + Clone,
-{
-    type Item = super::VariantList;
-
-    fn to_network(&self) -> Self::Item {
-        self.iter().map(|i| (*i).clone().into()).collect()
-    }
-
-    fn from_network(input: &mut Self::Item) -> Self {
-        input
-            .iter()
-            .map(|i| match T::try_from(i.clone()) {
-                Ok(it) => it,
-                // TODO handle error
-                _ => unreachable!(),
-            })
-            .collect()
-    }
-}
-
-/// Implements the Network trait genericly for everything that
-/// can be a VariantList / Vec<T>
-impl<T, S> crate::message::Network for HashMap<T, S>
+impl<T, S> crate::message::NetworkList for HashMap<T, S>
 where
     T: std::convert::TryFrom<Variant> + Into<Variant> + Clone + std::hash::Hash + std::cmp::Eq,
     S: std::convert::TryFrom<Variant> + Into<Variant> + Clone + std::hash::Hash + std::cmp::Eq,
 {
-    type Item = super::VariantList;
-
-    fn to_network(&self) -> Self::Item {
+    fn to_network_list(&self) -> VariantList {
         let mut res = Vec::with_capacity(self.len() * 2);
 
         self.iter().for_each(|(k, v)| {
@@ -128,7 +102,7 @@ where
         return res;
     }
 
-    fn from_network(input: &mut Self::Item) -> Self {
+    fn from_network_list(input: &mut VariantList) -> Self {
         let mut res = HashMap::with_capacity(input.len() / 2);
 
         input.iter().tuples().for_each(|(k, v)| {
diff --git a/src/primitive/variantlist.rs b/src/primitive/variantlist.rs
index b3ca720..d3518e6 100644
--- a/src/primitive/variantlist.rs
+++ b/src/primitive/variantlist.rs
@@ -45,3 +45,33 @@ impl Deserialize for VariantList {
         return Ok((pos, res));
     }
 }
+
+impl<S> crate::message::NetworkMap for Vec<S>
+where
+    S: std::convert::TryFrom<Variant> + Into<Variant> + Clone + std::hash::Hash + std::cmp::Eq,
+    <S as TryFrom<Variant>>::Error: std::fmt::Debug,
+{
+    type Item = VariantList;
+
+    fn to_network_map(&self) -> VariantList {
+        self.iter().map(|i| i.clone().into()).collect()
+    }
+
+    fn from_network_map(input: &mut VariantList) -> Self {
+        input.iter().map(|i| i.clone().try_into().unwrap()).collect()
+    }
+}
+
+impl<S> crate::message::NetworkList for Vec<S>
+where
+    S: std::convert::TryFrom<Variant> + Into<Variant> + Clone + std::hash::Hash + std::cmp::Eq,
+    <S as TryFrom<Variant>>::Error: std::fmt::Debug,
+{
+    fn to_network_list(&self) -> VariantList {
+        self.iter().map(|i| i.clone().into()).collect()
+    }
+
+    fn from_network_list(input: &mut VariantList) -> Self {
+        input.iter().map(|i| i.clone().try_into().unwrap()).collect()
+    }
+}
diff --git a/src/util.rs b/src/util.rs
index 251e089..98e3521 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -42,11 +42,11 @@ pub fn insert_bytes(pos: usize, buf: &mut Vec<u8>, input: &mut [u8]) {
 macro_rules! map {
     // map-like
     ($($k:expr => $v:expr),* $(,)?) => {
-        std::iter::Iterator::collect(std::array::IntoIter::new([$(($k, $v),)*]))
+        std::iter::Iterator::collect(std::iter::IntoIterator::into_iter([$(($k, $v),)*]))
     };
     // set-like
     ($($v:expr),* $(,)?) => {
-        std::iter::Iterator::collect(std::array::IntoIter::new([$($v,)*]))
+        std::iter::Iterator::collect(std::iter::IntoIterator::into_iter([$($v,)*]))
     };
 }