NetworkMap error handling

14 files changed, 125 insertions, 129 deletions

diff --git a/src/message/signalproxy/initdata.rs b/src/message/signalproxy/initdata.rs
index e693971..b69572a 100644
--- a/src/message/signalproxy/initdata.rs
+++ b/src/message/signalproxy/initdata.rs
@@ -20,7 +20,7 @@ impl Serialize for InitData {
         res.push(Variant::ByteArray(self.class_name.clone()));
         res.push(Variant::ByteArray(self.object_name.clone()));
 
-        res.append(&mut self.init_data.to_network());
+        res.append(&mut self.init_data.to_network()?);
 
         res.serialize()
     }
@@ -40,7 +40,7 @@ impl Deserialize for InitData {
             Self {
                 class_name: class_name.clone(),
                 object_name: object_name.clone(),
-                init_data: Types::from_network(class_name.as_str(), object_name.as_str(), &mut res),
+                init_data: Types::from_network(class_name.as_str(), object_name.as_str(), &mut res)?,
             },
         ))
     }
diff --git a/src/message/signalproxy/mod.rs b/src/message/signalproxy/mod.rs
index eb64dad..a839215 100644
--- a/src/message/signalproxy/mod.rs
+++ b/src/message/signalproxy/mod.rs
@@ -159,7 +159,7 @@ where
     where
         Self: Sized,
     {
-        self.send_sync("update", vec![self.to_network_map().into()])
+        self.send_sync("update", vec![self.to_network_map()?.into()])
     }
 
     /// Server -> Client: Update the whole object with received data
@@ -167,7 +167,7 @@ where
     where
         Self: Sized,
     {
-        *self = Self::from_network_map(&mut param);
+        *self = Self::from_network_map(&mut param)?;
         Ok(())
     }
 }
@@ -206,7 +206,7 @@ pub trait StatefulSyncableClient: Syncable + translation::NetworkMap {
     where
         Self: Sized,
     {
-        *self = Self::from_network_map(&mut param);
+        *self = Self::from_network_map(&mut param)?;
         Ok(())
     }
 
@@ -215,7 +215,7 @@ pub trait StatefulSyncableClient: Syncable + translation::NetworkMap {
     where
         Self: Sized,
     {
-        self.send_sync("requestUpdate", vec![self.to_network_map().into()])
+        self.send_sync("requestUpdate", vec![self.to_network_map()?.into()])
     }
 }
 
diff --git a/src/message/signalproxy/objects/aliasmanager.rs b/src/message/signalproxy/objects/aliasmanager.rs
index 2e2610c..7bd3ea3 100644
--- a/src/message/signalproxy/objects/aliasmanager.rs
+++ b/src/message/signalproxy/objects/aliasmanager.rs
@@ -28,7 +28,7 @@ pub struct AliasManager {
 impl AliasManager {
     pub fn add_alias(&mut self, alias: Alias) -> Result<()> {
         #[cfg(feature = "server")]
-        sync!("addAlias", [alias.to_network_map()])?;
+        sync!("addAlias", [alias.to_network_map()?])?;
 
         if !self.aliases.contains(&alias) {
             self.aliases.push(alias)
@@ -52,7 +52,7 @@ impl StatefulSyncableServer for AliasManager {
                 msg.params
                     .pop()
                     .ok_or(crate::ProtocolError::MissingSyncMessageParams)?,
-            )?)),
+            )?)?),
             unknown => Err(crate::ProtocolError::UnknownMsgSlotName(unknown.to_string())),
         }
     }
diff --git a/src/message/signalproxy/objects/bufferviewmanager.rs b/src/message/signalproxy/objects/bufferviewmanager.rs
index 341fec2..5942375 100644
--- a/src/message/signalproxy/objects/bufferviewmanager.rs
+++ b/src/message/signalproxy/objects/bufferviewmanager.rs
@@ -24,15 +24,17 @@ pub struct BufferViewManager {
 // TODO add buffer view configs, where does the data come from?
 impl BufferViewManager {
     pub fn request_create_buffer_view(&self, properties: BufferViewConfig) -> Result<()> {
-        sync!("requestCreateBufferView", [properties.to_network_map()])
+        sync!("requestCreateBufferView", [properties.to_network_map()?])
     }
 
     pub fn request_create_buffer_views(&self, properties: &[BufferViewConfig]) -> Result<()> {
+        let properties = properties.iter().map(|view| view.to_network_map()).collect::<Result<Vec<VariantMap>>>()?;
+
         self.send_sync(
             "requestCreateBufferViews",
             properties
-                .iter()
-                .map(|view| view.to_network_map().into())
+                .into_iter()
+                .map(|view| view.into())
                 .collect(),
         )
     }
@@ -109,11 +111,11 @@ impl StatefulSyncableServer for BufferViewManager {
         match msg.slot_name.as_str() {
             "requestCreateBufferView" => self.add_buffer_view_config(BufferViewConfig::from_network_map(
                 &mut msg.params.remove(0).try_into()?,
-            )),
+            )?),
             "requestCreateBufferViews" => {
                 let views: VariantList = msg.params.remove(0).try_into()?;
                 for view in views.into_iter() {
-                    self.add_buffer_view_config(BufferViewConfig::from_network_map(&mut view.try_into()?))?
+                    self.add_buffer_view_config(BufferViewConfig::from_network_map(&mut view.try_into()?)?)?
                 }
                 Ok(())
             }
@@ -165,7 +167,7 @@ impl super::NetworkList for BufferViewManager {
 impl super::NetworkMap for BufferViewManager {
     type Item = VariantMap;
 
-    fn to_network_map(&self) -> Self::Item {
+    fn to_network_map(&self) -> Result<Self::Item> {
         let mut res = VariantMap::new();
 
         res.insert(
@@ -173,13 +175,13 @@ impl super::NetworkMap for BufferViewManager {
             Variant::VariantList(self.buffer_view_configs.keys().map(|k| i32::into(*k)).collect()),
         );
 
-        res
+        Ok(res)
     }
 
-    fn from_network_map(_input: &mut Self::Item) -> Self {
+    fn from_network_map(_input: &mut Self::Item) -> Result<Self> {
         // TODO Somehow do the initrequests for all the IDs we get here
-        Self {
+        Ok(Self {
             buffer_view_configs: HashMap::new(),
-        }
+        })
     }
 }
diff --git a/src/message/signalproxy/objects/chanmodes.rs b/src/message/signalproxy/objects/chanmodes.rs
index b297126..3781ba4 100644
--- a/src/message/signalproxy/objects/chanmodes.rs
+++ b/src/message/signalproxy/objects/chanmodes.rs
@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use crate::{
     message::NetworkMap,
     primitive::{StringList, Variant, VariantMap},
+    Result,
 };
 
 #[derive(Debug, Clone, PartialEq)]
@@ -26,7 +27,7 @@ pub struct ChanModes {
 impl NetworkMap for ChanModes {
     type Item = VariantMap;
 
-    fn to_network_map(&self) -> Self::Item {
+    fn to_network_map(&self) -> Result<Self::Item> {
         let mut map = VariantMap::new();
 
         map.insert(
@@ -58,15 +59,15 @@ impl NetworkMap for ChanModes {
         );
         map.insert(s!("D"), Variant::String(self.channel_modes_d.clone()));
 
-        map
+        Ok(map)
     }
 
-    fn from_network_map(input: &mut Self::Item) -> Self {
+    fn from_network_map(input: &mut Self::Item) -> Result<Self> {
         let channel_modes_a: VariantMap = input.remove("A").unwrap().try_into().unwrap();
         let channel_modes_b: VariantMap = input.remove("B").unwrap().try_into().unwrap();
         let channel_modes_c: VariantMap = input.remove("C").unwrap().try_into().unwrap();
 
-        ChanModes {
+        Ok(ChanModes {
             channel_modes_a: channel_modes_a
                 .into_iter()
                 .map(|(mut k, v)| (k.remove(0), v.try_into().unwrap()))
@@ -80,7 +81,7 @@ impl NetworkMap for ChanModes {
                 .map(|(mut k, v)| (k.remove(0), v.try_into().unwrap()))
                 .collect(),
             channel_modes_d: input.remove("D").unwrap().try_into().unwrap(),
-        }
+        })
     }
 }
 
@@ -129,11 +130,11 @@ mod tests {
 
     #[test]
     fn chanmodes_to_network() {
-        assert_eq!(get_runtime().to_network_map(), get_network())
+        assert_eq!(get_runtime().to_network_map().unwrap(), get_network())
     }
 
     #[test]
     fn chanmodes_from_network() {
-        assert_eq!(ChanModes::from_network_map(&mut get_network()), get_runtime())
+        assert_eq!(ChanModes::from_network_map(&mut get_network()).unwrap(), get_runtime())
     }
 }
diff --git a/src/message/signalproxy/objects/coreinfo.rs b/src/message/signalproxy/objects/coreinfo.rs
index c901f91..9b8e7cc 100644
--- a/src/message/signalproxy/objects/coreinfo.rs
+++ b/src/message/signalproxy/objects/coreinfo.rs
@@ -15,7 +15,7 @@ pub struct CoreInfo {
 impl CoreInfo {
     pub fn set_core_data(&mut self, data: CoreData) -> Result<()> {
         #[cfg(feature = "server")]
-        libquassel_derive::sync!("setCoreData", [data.to_network_map()])?;
+        libquassel_derive::sync!("setCoreData", [data.to_network_map()?])?;
 
         self.core_data = data;
 
@@ -31,7 +31,7 @@ impl crate::message::StatefulSyncableClient for CoreInfo {
     {
         #[allow(clippy::single_match)]
         match msg.slot_name.as_str() {
-            "setCoreData" => self.set_core_data(CoreData::from_network_map(&mut get_param!(msg))),
+            "setCoreData" => self.set_core_data(CoreData::from_network_map(&mut get_param!(msg))?),
             unknown => Err(crate::ProtocolError::UnknownMsgSlotName(unknown.to_string())),
         }
     }
diff --git a/src/message/signalproxy/objects/identity.rs b/src/message/signalproxy/objects/identity.rs
index f12e882..a3ae7ed 100644
--- a/src/message/signalproxy/objects/identity.rs
+++ b/src/message/signalproxy/objects/identity.rs
@@ -72,7 +72,7 @@ impl UserType for Identity {
 
 impl Serialize for Identity {
     fn serialize(&self) -> Result<Vec<u8>> {
-        self.to_network_map().serialize()
+        self.to_network_map()?.serialize()
     }
 }
 
@@ -82,14 +82,14 @@ impl Deserialize for Identity {
         Self: std::marker::Sized,
     {
         let (vlen, mut value) = VariantMap::parse(b)?;
-        Ok((vlen, Self::from_network_map(&mut value)))
+        Ok((vlen, Self::from_network_map(&mut value)?))
     }
 }
 
 impl Identity {
     pub fn copy_from(&mut self, other: Identity) -> Result<()> {
         #[cfg(feature = "server")]
-        sync!("copyFrom", [other.to_network_map()])?;
+        sync!("copyFrom", [other.to_network_map()?])?;
 
         *self = other;
 
@@ -104,7 +104,7 @@ impl StatefulSyncableClient for Identity {
         Self: Sized,
     {
         match msg.slot_name.as_str() {
-            "copyFrom" => self.copy_from(Identity::from_network_map(&mut get_param!(msg))),
+            "copyFrom" => self.copy_from(Identity::from_network_map(&mut get_param!(msg))?),
             "setAutoAwayEnabled" => self.set_auto_away_enabled(get_param!(msg)),
             "setAutoAwayReason" => self.set_auto_away_reason(get_param!(msg)),
             "setAutoAwayReasonEnabled" => self.set_auto_away_reason_enabled(get_param!(msg)),
diff --git a/src/message/signalproxy/objects/ircchannel.rs b/src/message/signalproxy/objects/ircchannel.rs
index 2f88cb5..87c5d5a 100644
--- a/src/message/signalproxy/objects/ircchannel.rs
+++ b/src/message/signalproxy/objects/ircchannel.rs
@@ -38,7 +38,7 @@ impl UserType for IrcChannel {
 
 impl Serialize for IrcChannel {
     fn serialize(&self) -> Result<Vec<u8>> {
-        self.to_network_map().serialize()
+        self.to_network_map()?.serialize()
     }
 }
 
@@ -48,7 +48,7 @@ impl Deserialize for IrcChannel {
         Self: std::marker::Sized,
     {
         let (vlen, mut value) = VariantMap::parse(b)?;
-        Ok((vlen, Self::from_network_map(&mut value)))
+        Ok((vlen, Self::from_network_map(&mut value)?))
     }
 }
 
@@ -317,12 +317,12 @@ mod tests {
 
     #[test]
     fn ircchannel_to_network() {
-        assert_eq!(get_runtime().to_network_map(), get_network())
+        assert_eq!(get_runtime().to_network_map().unwrap(), get_network())
     }
 
     #[test]
     fn ircchannel_from_network() {
-        assert_eq!(IrcChannel::from_network_map(&mut get_network()), get_runtime())
+        assert_eq!(IrcChannel::from_network_map(&mut get_network()).unwrap(), get_runtime())
     }
 
     #[test]
diff --git a/src/message/signalproxy/objects/ircuser.rs b/src/message/signalproxy/objects/ircuser.rs
index a35e57d..226bca3 100644
--- a/src/message/signalproxy/objects/ircuser.rs
+++ b/src/message/signalproxy/objects/ircuser.rs
@@ -50,7 +50,7 @@ impl UserType for IrcUser {
 
 impl Serialize for IrcUser {
     fn serialize(&self) -> Result<Vec<u8>> {
-        self.to_network_map().serialize()
+        self.to_network_map()?.serialize()
     }
 }
 
@@ -60,7 +60,7 @@ impl Deserialize for IrcUser {
         Self: std::marker::Sized,
     {
         let (vlen, mut value) = VariantMap::parse(b)?;
-        Ok((vlen, Self::from_network_map(&mut value)))
+        Ok((vlen, Self::from_network_map(&mut value)?))
     }
 }
 
@@ -333,16 +333,16 @@ mod tests {
 
     #[test]
     fn ircuser_to_network() {
-        assert_eq!(get_runtime().to_network_map(), get_network())
+        assert_eq!(get_runtime().to_network_map().unwrap(), get_network())
     }
 
     #[test]
     fn ircuser_from_network() {
-        assert_eq!(IrcUser::from_network_map(&mut get_network()), get_runtime())
+        assert_eq!(IrcUser::from_network_map(&mut get_network()).unwrap(), get_runtime())
     }
 
     #[test]
     fn vec_ircuser_to_network() {
-        assert_eq!(get_runtime().to_network_map(), get_network())
+        assert_eq!(get_runtime().to_network_map().unwrap(), get_network())
     }
 }
diff --git a/src/message/signalproxy/objects/mod.rs b/src/message/signalproxy/objects/mod.rs
index 19a8dd1..a196add 100644
--- a/src/message/signalproxy/objects/mod.rs
+++ b/src/message/signalproxy/objects/mod.rs
@@ -37,6 +37,7 @@ use log::debug;
 
 use super::{NetworkList, NetworkMap};
 use crate::primitive::VariantList;
+use crate::Result;
 
 /// Central Enum containing and identifying all Quassel Protocol Types:
 ///
@@ -77,31 +78,31 @@ pub enum Types {
 }
 
 impl Types {
-    pub fn to_network(&self) -> VariantList {
+    pub fn to_network(&self) -> Result<VariantList> {
         debug!("converting to network object: {:#?}", self);
-        match self {
-            Types::AliasManager(val) => val.to_network_list().unwrap(),
-            Types::BufferSyncer(val) => val.to_network_list().unwrap(),
-            Types::BufferViewConfig(val) => val.to_network_list().unwrap(),
-            Types::BufferViewManager(val) => val.to_network_list().unwrap(),
+        Ok(match self {
+            Types::AliasManager(val) => val.to_network_list()?,
+            Types::BufferSyncer(val) => val.to_network_list()?,
+            Types::BufferViewConfig(val) => val.to_network_list()?,
+            Types::BufferViewManager(val) => val.to_network_list()?,
             // Types::CoreInfo(val) => vec![val.to_network_map().into()],
-            Types::CoreData(val) => vec![val.to_network_map().into()],
-            Types::HighlightRuleManager(val) => val.to_network_list().unwrap(),
-            Types::IgnoreListManager(val) => val.to_network_list().unwrap(),
-            Types::CertManager(val) => val.to_network_list().unwrap(),
-            Types::Network(val) => val.to_network_list().unwrap(),
-            Types::NetworkInfo(val) => val.to_network_list().unwrap(),
-            Types::NetworkConfig(val) => val.to_network_list().unwrap(),
-            Types::IrcChannel(val) => val.to_network_list().unwrap(),
+            Types::CoreData(val) => vec![val.to_network_map()?.into()],
+            Types::HighlightRuleManager(val) => val.to_network_list()?,
+            Types::IgnoreListManager(val) => val.to_network_list()?,
+            Types::CertManager(val) => val.to_network_list()?,
+            Types::Network(val) => val.to_network_list()?,
+            Types::NetworkInfo(val) => val.to_network_list()?,
+            Types::NetworkConfig(val) => val.to_network_list()?,
+            Types::IrcChannel(val) => val.to_network_list()?,
             Types::Unknown(val) => *val.clone(),
-        }
+        })
     }
 
-    pub fn from_network(class_name: &str, object_name: &str, input: &mut VariantList) -> Self {
+    pub fn from_network(class_name: &str, object_name: &str, input: &mut VariantList) -> Result<Self> {
         debug!("converting {} from network object: {:#?}", class_name, input);
-        match class_name {
-            "AliasManager" => Types::AliasManager(Box::new(AliasManager::from_network_list(input).unwrap())),
-            "BufferSyncer" => Types::BufferSyncer(Box::new(BufferSyncer::from_network_list(input).unwrap())),
+        Ok(match class_name {
+            "AliasManager" => Types::AliasManager(Box::new(AliasManager::from_network_list(input)?)),
+            "BufferSyncer" => Types::BufferSyncer(Box::new(BufferSyncer::from_network_list(input)?)),
             "BufferViewConfig" => {
                 let mut config = BufferViewConfig::from_network_list(input).unwrap();
                 config.buffer_view_id = object_name.parse().unwrap();
@@ -115,7 +116,7 @@ impl Types {
             // )),
             "CoreData" => Types::CoreData(Box::new(CoreData::from_network_map(
                 &mut input.remove(0).try_into().unwrap(),
-            ))),
+            )?)),
             "HighlightRuleManager" => {
                 Types::HighlightRuleManager(Box::new(HighlightRuleManager::from_network_list(input).unwrap()))
             }
@@ -130,6 +131,6 @@ impl Types {
             }
             "IrcChannel" => Types::IrcChannel(Box::new(IrcChannel::from_network_list(input).unwrap())),
             _ => Types::Unknown(Box::new(input.to_owned())),
-        }
+        })
     }
 }
diff --git a/src/message/signalproxy/objects/network.rs b/src/message/signalproxy/objects/network.rs
index c5cdd1a..fac68a7 100644
--- a/src/message/signalproxy/objects/network.rs
+++ b/src/message/signalproxy/objects/network.rs
@@ -108,7 +108,7 @@ impl Network {
 
     pub fn set_network_info(&mut self, network_info: NetworkInfo) -> Result<()> {
         #[cfg(feature = "client")]
-        sync!("requestSetNetworkInfo", [network_info.to_network_map()])?;
+        sync!("requestSetNetworkInfo", [network_info.to_network_map()?])?;
 
         self.network_info = network_info;
 
@@ -253,7 +253,7 @@ impl crate::message::StatefulSyncableClient for Network {
             "setNetworkName" => self.network_info.set_network_name(get_param!(msg)),
             "setNetworkInfo" => {
                 let mut map = VariantMap::try_from(msg.params.remove(0))?;
-                self.set_network_info(NetworkInfo::from_network_map(&mut map))
+                self.set_network_info(NetworkInfo::from_network_map(&mut map)?)
             }
             "setPerform" => self.network_info.set_perform(get_param!(msg)),
             "setRejoinChannels" => self.network_info.set_rejoin_channels(get_param!(msg)),
@@ -263,7 +263,7 @@ impl crate::message::StatefulSyncableClient for Network {
             "setActualServerList" => self.network_info.set_server_list({
                 match msg.params.remove(0) {
                     Variant::VariantList(mut variants) => {
-                        Vec::<NetworkServer>::from_network_map(&mut variants)
+                        Vec::<NetworkServer>::from_network_map(&mut variants)?
                     }
                     _ => {
                         error!("{}", ProtocolError::WrongVariant);
@@ -297,7 +297,7 @@ impl crate::message::StatefulSyncableServer for Network {
             "requestDisconnect" => self.disconnect(),
             "requestSetNetworkInfo" => {
                 let mut map = VariantMap::try_from(msg.params.remove(0))?;
-                self.set_network_info(NetworkInfo::from_network_map(&mut map))
+                self.set_network_info(NetworkInfo::from_network_map(&mut map)?)
             }
             unknown => Err(ProtocolError::UnknownMsgSlotName(unknown.to_string())),
         }
@@ -347,22 +347,17 @@ impl crate::message::signalproxy::NetworkList for Network {
         {
             let mut map = VariantMap::new();
 
-            map.insert(
-                s!("Users"),
-                Variant::VariantMap(self.irc_users.iter().fold(HashMap::new(), |mut res, (_, v)| {
-                    res.extend(v.to_network_map());
-
-                    res
-                })),
-            );
-
-            let channels = self.irc_channels.iter().fold(HashMap::new(), |mut res, (_, v)| {
-                res.extend(v.to_network_map());
-
-                res
-            });
+            let mut irc_users = HashMap::new();
+            for (_, user) in self.irc_users.clone() {
+                irc_users.extend(user.to_network_map()?);
+            }
+            map.insert(s!("Users"), Variant::VariantMap(irc_users));
 
-            map.insert(s!("Channels"), Variant::VariantMap(channels));
+            let mut irc_channels = HashMap::new();
+            for (_, channel) in self.irc_channels.clone() {
+                irc_channels.extend(channel.to_network_map()?);
+            }
+            map.insert(s!("Channels"), Variant::VariantMap(irc_channels));
 
             res.push(Variant::ByteArray(s!("IrcUsersAndChannels")));
             res.push(Variant::VariantMap(map));
@@ -426,7 +421,7 @@ impl crate::message::signalproxy::NetworkList for Network {
                     Some(users) => {
                         let users: Vec<IrcUser> = Vec::<IrcUser>::from_network_map(
                             &mut users.try_into().expect("failed to convert Users"),
-                        );
+                        )?;
 
                         users.into_iter().map(|user| (user.nick.clone(), user)).collect()
                     }
@@ -437,7 +432,7 @@ impl crate::message::signalproxy::NetworkList for Network {
                 match users_and_channels.get("Channels") {
                     Some(channels) => {
                         let channels: Vec<IrcChannel> =
-                            Vec::<IrcChannel>::from_network_map(&mut channels.try_into()?);
+                            Vec::<IrcChannel>::from_network_map(&mut channels.try_into()?)?;
                         channels
                             .into_iter()
                             .map(|channel| (channel.name.clone(), channel))
@@ -483,7 +478,7 @@ impl crate::message::signalproxy::NetworkList for Network {
 impl crate::message::signalproxy::NetworkMap for Network {
     type Item = VariantMap;
 
-    fn to_network_map(&self) -> Self::Item {
+    fn to_network_map(&self) -> Result<Self::Item> {
         let mut res = VariantMap::new();
 
         res.insert("myNick".to_owned(), Variant::String(self.my_nick.clone()));
@@ -531,36 +526,31 @@ impl crate::message::signalproxy::NetworkMap for Network {
         res.insert(s!("IrcUsersAndChannels"), {
             let mut map = VariantMap::new();
 
-            map.insert(
-                s!("Users"),
-                Variant::VariantMap(self.irc_users.iter().fold(HashMap::new(), |mut res, (_, v)| {
-                    res.extend(v.to_network_map());
-
-                    res
-                })),
-            );
-
-            let channels = self.irc_channels.iter().fold(HashMap::new(), |mut res, (_, v)| {
-                res.extend(v.to_network_map());
-
-                res
-            });
+            let mut irc_users = HashMap::new();
+            for (_, user) in self.irc_users.clone() {
+                irc_users.extend(user.to_network_map()?);
+            }
+            map.insert(s!("Users"), Variant::VariantMap(irc_users));
 
-            map.insert(s!("Channels"), Variant::VariantMap(channels));
+            let mut irc_channels = HashMap::new();
+            for (_, channel) in self.irc_channels.clone() {
+                irc_channels.extend(channel.to_network_map()?);
+            }
+            map.insert(s!("Channels"), Variant::VariantMap(irc_channels));
 
             Variant::VariantMap(map)
         });
 
-        res.extend(self.network_info.to_network_map());
+        res.extend(self.network_info.to_network_map()?);
 
-        res
+        Ok(res)
     }
 
-    fn from_network_map(input: &mut Self::Item) -> Self {
+    fn from_network_map(input: &mut Self::Item) -> Result<Self> {
         let mut users_and_channels: VariantMap =
             { input.remove("IrcUsersAndChannels").unwrap().try_into().unwrap() };
 
-        Self {
+        Ok(Self {
             my_nick: input.remove("myNick").unwrap().try_into().unwrap(),
             latency: input.remove("latency").unwrap().try_into().unwrap(),
             current_server: input.remove("currentServer").unwrap().try_into().unwrap(),
@@ -577,7 +567,7 @@ impl crate::message::signalproxy::NetworkMap for Network {
                     Some(users) => {
                         let users: Vec<IrcUser> = Vec::<IrcUser>::from_network_map(
                             &mut users.try_into().expect("failed to convert Users"),
-                        );
+                        )?;
 
                         users.into_iter().map(|user| (user.nick.clone(), user)).collect()
                     }
@@ -588,7 +578,7 @@ impl crate::message::signalproxy::NetworkMap for Network {
                 match users_and_channels.remove("Channels") {
                     Some(channels) => {
                         let channels: Vec<IrcChannel> =
-                            Vec::<IrcChannel>::from_network_map(&mut channels.try_into().unwrap());
+                            Vec::<IrcChannel>::from_network_map(&mut channels.try_into().unwrap())?;
                         channels
                             .into_iter()
                             .map(|channel| (channel.name.clone(), channel))
@@ -612,8 +602,8 @@ impl crate::message::signalproxy::NetworkMap for Network {
                 .into_iter()
                 .map(|v| v.try_into().unwrap())
                 .collect(),
-            network_info: NetworkInfo::from_network_map(input),
-        }
+            network_info: NetworkInfo::from_network_map(input)?,
+        })
     }
 }
 
@@ -665,7 +655,7 @@ impl UserType for NetworkServer {
 
 impl Serialize for NetworkServer {
     fn serialize(&self) -> Result<Vec<u8>> {
-        self.to_network_map().serialize()
+        self.to_network_map()?.serialize()
     }
 }
 
@@ -675,7 +665,7 @@ impl Deserialize for NetworkServer {
         Self: std::marker::Sized,
     {
         let (vlen, mut value) = VariantMap::parse(b)?;
-        Ok((vlen, Self::from_network_map(&mut value)))
+        Ok((vlen, Self::from_network_map(&mut value)?))
     }
 }
 
@@ -743,7 +733,7 @@ mod tests {
     #[test]
     fn network_server_to_network() {
         assert_eq!(
-            networkserver_get_runtime().to_network_map(),
+            networkserver_get_runtime().to_network_map().unwrap(),
             networkserver_get_network()
         )
     }
diff --git a/src/message/signalproxy/objects/networkinfo.rs b/src/message/signalproxy/objects/networkinfo.rs
index bc08989..1a41f84 100644
--- a/src/message/signalproxy/objects/networkinfo.rs
+++ b/src/message/signalproxy/objects/networkinfo.rs
@@ -77,7 +77,7 @@ impl UserType for NetworkInfo {
 
 impl Serialize for NetworkInfo {
     fn serialize(&self) -> Result<Vec<u8>> {
-        self.to_network_map().serialize()
+        self.to_network_map()?.serialize()
     }
 }
 
@@ -87,7 +87,7 @@ impl Deserialize for NetworkInfo {
         Self: std::marker::Sized,
     {
         let (vlen, mut value) = VariantMap::parse(b)?;
-        Ok((vlen, Self::from_network_map(&mut value)))
+        Ok((vlen, Self::from_network_map(&mut value)?))
     }
 }
 
@@ -98,7 +98,7 @@ impl NetworkInfo {
             use crate::message::NetworkMap;
             use libquassel_derive::sync;
 
-            sync!("setServerList", [Vec::<NetworkServer>::to_network_map(&servers)])?;
+            sync!("setServerList", [Vec::<NetworkServer>::to_network_map(&servers)?])?;
         }
 
         self.server_list = servers;
diff --git a/src/message/signalproxy/translation.rs b/src/message/signalproxy/translation.rs
index 7121032..40ebac1 100644
--- a/src/message/signalproxy/translation.rs
+++ b/src/message/signalproxy/translation.rs
@@ -93,7 +93,7 @@
 //! ```
 use crate::{
     primitive::{Variant, VariantList},
-    ProtocolError,
+    ProtocolError, Result,
 };
 
 #[deprecated(
@@ -109,18 +109,20 @@ pub trait Network {
 
 pub trait NetworkMap
 where
-    Self::Item: TryFrom<Variant, Error = crate::error::ProtocolError>,
+    Self::Item: TryFrom<Variant, Error = ProtocolError>,
     Self::Item: Into<Variant>,
 {
     type Item;
 
-    fn to_network_map(&self) -> Self::Item;
-    fn from_network_map(input: &mut Self::Item) -> Self;
+    fn to_network_map(&self) -> Result<Self::Item>;
+    fn from_network_map(input: &mut Self::Item) -> Result<Self>
+    where
+        Self: std::marker::Sized;
 }
 
 pub trait NetworkList {
-    fn to_network_list(&self) -> Result<VariantList, ProtocolError>;
-    fn from_network_list(input: &mut VariantList) -> Result<Self, ProtocolError>
+    fn to_network_list(&self) -> Result<VariantList>;
+    fn from_network_list(input: &mut VariantList) -> Result<Self>
     where
         Self: std::marker::Sized;
 }
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index b201b46..a7db7c3 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -3,11 +3,11 @@ use std::{collections::HashMap, vec::Vec};
 use itertools::Itertools;
 use log::{error, trace};
 
-use crate::error::ProtocolError;
 use crate::message::objects::{Identity, IrcChannel, IrcUser, NetworkInfo, NetworkServer};
 use crate::primitive::{self, NetworkId, PeerPtr};
 use crate::primitive::{IdentityId, StringList};
 use crate::serialize::*;
+use crate::{ProtocolError, Result};
 
 use crate::primitive::{BufferId, BufferInfo, Date, DateTime, Message, MsgId, Time, VariantList, VariantMap};
 
@@ -64,7 +64,7 @@ pub enum Variant {
 impl TryFrom<Variant> for String {
     type Error = ProtocolError;
 
-    fn try_from(input: Variant) -> Result<Self, Self::Error> {
+    fn try_from(input: Variant) -> Result<Self> {
         match input {
             Variant::String(value) => Ok(value),
             Variant::ByteArray(value) => Ok(value),
@@ -92,7 +92,7 @@ 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,
 {
-    fn to_network_list(&self) -> Result<VariantList, ProtocolError> {
+    fn to_network_list(&self) -> Result<VariantList> {
         let mut res = Vec::with_capacity(self.len() * 2);
 
         self.iter().for_each(|(k, v)| {
@@ -103,7 +103,7 @@ where
         Ok(res)
     }
 
-    fn from_network_list(input: &mut VariantList) -> Result<Self, ProtocolError> {
+    fn from_network_list(input: &mut VariantList) -> Result<Self> {
         let mut res = HashMap::with_capacity(input.len() / 2);
 
         input.iter().tuples().for_each(|(k, v)| {
@@ -129,18 +129,18 @@ where
 {
     type Item = super::VariantMap;
 
-    fn to_network_map(&self) -> Self::Item {
+    fn to_network_map(&self) -> Result<Self::Item> {
         let mut res = HashMap::with_capacity(self.len());
 
         self.iter().for_each(|(k, v)| {
             res.insert(k.clone(), (*v).clone().into());
         });
 
-        res
+        Ok(res)
     }
 
-    fn from_network_map(input: &mut Self::Item) -> Self {
-        input
+    fn from_network_map(input: &mut Self::Item) -> Result<Self> {
+        Ok(input
             .iter_mut()
             .map(|(k, v)| {
                 (
@@ -151,12 +151,12 @@ where
                     },
                 )
             })
-            .collect()
+            .collect())
     }
 }
 
 impl Serialize for Variant {
-    fn serialize(&self) -> Result<Vec<u8>, ProtocolError> {
+    fn serialize(&self) -> Result<Vec<u8>> {
         match self {
             Variant::Unknown => Err(ProtocolError::UnknownVariant),
             Variant::VariantMap(v) => v.serialize_variant(),
@@ -208,7 +208,7 @@ impl Serialize for Variant {
 }
 
 impl Deserialize for Variant {
-    fn parse(b: &[u8]) -> Result<(usize, Self), ProtocolError> {
+    fn parse(b: &[u8]) -> Result<(usize, Self)> {
         trace!("trying to parse variant with bytes: {:x?}", b);
         let (_, qtype) = i32::parse(&b[0..4])?;
         let qtype = qtype as u32;