WIP: impl signalproxy types

14 files changed, 376 insertions, 253 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 94366cf..0789077 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,7 +25,7 @@ libquassel-derive = { path = "./derive" }
 
 bytes = { version = "1.0", optional = true }
 flate2 = { version = "1.0", features = ["tokio"], optional = true }
-tokio = { version = "1.0", features = [], optional = true }
+tokio = { version = "1", features = [], optional = true }
 tokio-util = { version = "0.6", features = ["codec"], optional = true }
 
 [features]
diff --git a/derive/src/from_network_impl.rs b/derive/src/from_network_impl.rs
index c3a3be2..ff05f1c 100644
--- a/derive/src/from_network_impl.rs
+++ b/derive/src/from_network_impl.rs
@@ -56,7 +56,7 @@ pub(crate) fn map_list(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
                     syn::parse_str(&field.from_map.as_ref().unwrap()).unwrap();
 
                 quote! {
-                    #field_name: match input.get(#field_rename).unwrap() {
+                    #field_name: match input.get_mut(#field_rename).unwrap() {
                         crate::primitive::Variant::VariantList(input) => match &input.remove(0) {
                             crate::primitive::Variant::#field_type(input) => input.iter().map(#field_map).collect(),
                             _ => unimplemented!()
@@ -66,7 +66,7 @@ pub(crate) fn map_list(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
                 }
             } else {
                 quote! {
-                    #field_name: match input.get(#field_rename).unwrap() {
+                    #field_name: match input.get_mut(#field_rename).unwrap() {
                         crate::primitive::Variant::VariantList(input) => match &input.remove(0) {
                             crate::primitive::Variant::#field_type(input) => input.clone(),
                             _ => unimplemented!()
diff --git a/derive/src/lib.rs b/derive/src/lib.rs
index 10605a4..ddbb49a 100644
--- a/derive/src/lib.rs
+++ b/derive/src/lib.rs
@@ -3,7 +3,7 @@ use syn;
 
 use syn::parse_macro_input;
 
-use darling::{FromDeriveInput, FromField, FromMeta};
+use darling::{FromDeriveInput, FromField, FromMeta, FromVariant};
 
 mod from_network_impl;
 mod to_network_impl;
@@ -107,7 +107,7 @@ pub fn network(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
                 return res;
             }
 
-            fn from_network(input: Self::Item) -> Self {
+            fn from_network(input: &mut Self::Item) -> Self {
                 Self {
                     #(#from_network_impl_center)*
                 }
@@ -115,7 +115,7 @@ pub fn network(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         }
     };
 
-    // println!("{}", gen);
+    println!("{}", gen);
 
     gen.into()
 }
@@ -142,3 +142,75 @@ fn get_field_type(field: &NetworkField) -> syn::Type {
         None => field.ty.clone(),
     }
 }
+
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(from), supports(enum_any))]
+struct Enum {
+    ident: syn::Ident,
+    attrs: Vec<syn::Attribute>,
+}
+
+#[derive(Debug, FromVariant)]
+#[darling(attributes(from))]
+struct EnumField {
+    ident: syn::Ident,
+    fields: darling::ast::Fields<syn::Type>,
+
+    #[darling(default)]
+    ignore: bool,
+}
+
+#[proc_macro_derive(From, attributes(from))]
+pub fn from(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as syn::DeriveInput);
+    // println!("{:#?}", input);
+
+    let network = Enum::from_derive_input(&input).unwrap();
+    // println!("{:#?}", network);
+
+    let enum_name = network.ident;
+
+    let fields: Vec<EnumField> = match &input.data {
+        syn::Data::Enum(data) => data
+            .variants
+            .iter()
+            .map(|field| EnumField::from_variant(field).expect("Could not parse field"))
+            .collect(),
+        _ => unimplemented!(),
+    };
+
+    let derives = fields
+        .iter()
+        .filter(|field| field.fields.fields.len() > 0 && !field.ignore)
+        .map(|field| {
+            let variant = &field.ident;
+            let inner_type = &field.fields.fields[0];
+
+            quote! {
+                impl From<#inner_type> for #enum_name {
+                    fn from(input: #inner_type) -> Self {
+                        Self::#variant(input)
+                    }
+                }
+
+                impl Into<#inner_type> for #enum_name {
+                    fn into(self) -> #inner_type {
+                        match self {
+                            Self::#variant(input) => input,
+                            _ => unimplemented!(),
+                        }
+                    }
+                }
+            }
+        });
+
+    // println!("{:#?}", fields);
+
+    let gen = quote! {
+        #(#derives)*
+    };
+
+    // println!("{}", gen);
+
+    gen.into()
+}
diff --git a/src/lib.rs b/src/lib.rs
index f96e7a7..a2a3a25 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,3 @@
-#![feature(array_value_iter)]
 #![feature(external_doc)]
 #![feature(doc_cfg)]
 #![doc(include = "../README.md")]
diff --git a/src/message/signalproxy/objects/aliasmanager.rs b/src/message/signalproxy/objects/aliasmanager.rs
index b816778..093163b 100644
--- a/src/message/signalproxy/objects/aliasmanager.rs
+++ b/src/message/signalproxy/objects/aliasmanager.rs
@@ -1,4 +1,4 @@
-use crate::primitive::{StringList, Variant, VariantList, VariantMap};
+use crate::primitive::{StringList, Variant, VariantMap};
 
 use crate::message::signalproxy::Network;
 
@@ -13,14 +13,45 @@ pub struct Alias {
     expansion: String,
 }
 
-impl Network for AliasManager {
-    type Item = VariantList;
+impl Alias {
+    fn from_network_internal(input: &VariantMap) -> Vec<Self> {
+        let names = match_variant!(input.get("names").unwrap(), Variant::StringList);
+        let expansions = match_variant!(input.get("expansions").unwrap(), Variant::StringList);
+
+        return names
+            .iter()
+            .zip(expansions)
+            .map(|(name, expansion)| Alias {
+                name: name.clone(),
+                expansion,
+            })
+            .collect();
+    }
+}
+
+impl Network for Alias {
+    type Item = VariantMap;
+
+    fn to_network(&self) -> Self::Item {
+        let mut map = VariantMap::new();
+        map.insert(s!("names"), Variant::StringList(vec![self.name.clone()]));
+        map.insert(
+            s!("expansions"),
+            Variant::StringList(vec![self.expansion.clone()]),
+        );
 
-    fn to_network(&self) -> VariantList {
-        let mut res = VariantList::new();
+        return map;
+    }
 
-        res.push(Variant::ByteArray(s!("Aliases")));
+    fn from_network(input: &mut Self::Item) -> Self {
+        Alias::from_network_internal(&input)[0].clone()
+    }
+}
 
+impl Network for AliasManager {
+    type Item = VariantMap;
+
+    fn to_network(&self) -> Self::Item {
         let (names, expansions) = self.aliases.iter().fold(
             (StringList::new(), StringList::new()),
             |(mut names, mut expansions), alias| {
@@ -34,17 +65,10 @@ impl Network for AliasManager {
         map.insert(s!("names"), Variant::StringList(names));
         map.insert(s!("expansions"), Variant::StringList(expansions));
 
-        res.push(Variant::VariantMap(map));
-
-        return res;
+        return map;
     }
 
-    fn from_network(input: crate::primitive::VariantList) -> Self {
-        let input = match &input[1] {
-            Variant::VariantMap(input) => input,
-            _ => unimplemented!(),
-        };
-
+    fn from_network(input: &mut Self::Item) -> Self {
         let names = match_variant!(input.get("names").unwrap(), Variant::StringList);
         let expansions = match_variant!(input.get("expansions").unwrap(), Variant::StringList);
 
@@ -80,24 +104,21 @@ mod tests {
         }
     }
 
-    fn get_dest() -> VariantList {
-        vec![
-            Variant::ByteArray(s!("Aliases")),
-            Variant::VariantMap(map! {
-                s!("names") => Variant::StringList(
-                    vec![
-                        s!("j"),
-                        s!("ns"),
-                    ],
-                ),
-                s!("expansions") => Variant::StringList(
-                    vec![
-                        s!("/join $0"),
-                        s!("/msg nickserv $0"),
-                    ],
-                ),
-            }),
-        ]
+    fn get_dest() -> VariantMap {
+        map! {
+            s!("names") => Variant::StringList(
+                vec![
+                    s!("j"),
+                    s!("ns"),
+                ],
+            ),
+            s!("expansions") => Variant::StringList(
+                vec![
+                    s!("/join $0"),
+                    s!("/msg nickserv $0"),
+                ],
+            ),
+        }
     }
 
     #[test]
@@ -107,7 +128,7 @@ mod tests {
 
     #[test]
     fn aliasmanager_from_network() {
-        assert_eq!(AliasManager::from_network(get_dest()), get_src())
+        assert_eq!(AliasManager::from_network(&mut get_dest()), get_src())
     }
 }
 
diff --git a/src/message/signalproxy/objects/ircchannel.rs b/src/message/signalproxy/objects/ircchannel.rs
index cd5cd3e..b15d789 100644
--- a/src/message/signalproxy/objects/ircchannel.rs
+++ b/src/message/signalproxy/objects/ircchannel.rs
@@ -91,7 +91,7 @@ impl Network for IrcChannel {
 
         res
     }
-    fn from_network(input: Self::Item) -> Self {
+    fn from_network(input: &mut Self::Item) -> Self {
         Self {
             channel_modes_a: match_variant!(
                 match_variant!(
@@ -284,6 +284,6 @@ mod tests {
 
     #[test]
     fn ircchannel_from_network() {
-        assert_eq!(IrcChannel::from_network(get_network()), get_runtime())
+        assert_eq!(IrcChannel::from_network(&mut get_network()), get_runtime())
     }
 }
diff --git a/src/message/signalproxy/objects/ircuser.rs b/src/message/signalproxy/objects/ircuser.rs
index 0ce597f..1064965 100644
--- a/src/message/signalproxy/objects/ircuser.rs
+++ b/src/message/signalproxy/objects/ircuser.rs
@@ -1,9 +1,26 @@
-use crate::primitive::{DateTime, StringList};
+use std::collections::HashMap;
+
+use crate::primitive::{DateTime, StringList, Variant, VariantMap};
 
 #[allow(unused_imports)]
 use crate::message::signalproxy::Network;
 use libquassel_derive::Network;
 
+impl Network for Vec<IrcUser> {
+    type Item = VariantMap;
+
+    fn to_network(&self) -> Self::Item {
+        Variant::VariantMap(self.iter().fold(HashMap::new(), |mut res, v| {
+            res.extend(v.to_network());
+
+            res
+        }))
+    }
+    fn from_network(input: &mut Self::Item) -> Self {
+        todo!()
+    }
+}
+
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq, Network)]
 #[network(repr = "maplist")]
@@ -196,6 +213,11 @@ mod tests {
 
     #[test]
     fn ircuser_from_network() {
-        assert_eq!(IrcUser::from_network(get_network()), get_runtime())
+        assert_eq!(IrcUser::from_network(&mut get_network()), get_runtime())
+    }
+
+    #[test]
+    fn vec_ircuser_to_network() {
+        assert_eq!(get_runtime().to_network(), get_network())
     }
 }
diff --git a/src/message/signalproxy/objects/mod.rs b/src/message/signalproxy/objects/mod.rs
index a313312..84f2f5a 100644
--- a/src/message/signalproxy/objects/mod.rs
+++ b/src/message/signalproxy/objects/mod.rs
@@ -1,13 +1,10 @@
-// mod aliasmanager;
-// mod backlogmanager;
-
 mod aliasmanager;
 mod buffersyncer;
 mod identity;
-mod ircchannel;
-mod ircuser;
-mod network;
-mod networkinfo;
+// mod ircchannel;
+// mod ircuser;
+// mod network;
+// mod networkinfo;
 
 pub use aliasmanager::*;
 pub use buffersyncer::*;
diff --git a/src/message/signalproxy/objects/network.rs b/src/message/signalproxy/objects/network.rs
index cb1edd2..4075499 100644
--- a/src/message/signalproxy/objects/network.rs
+++ b/src/message/signalproxy/objects/network.rs
@@ -28,221 +28,221 @@ pub struct Network {
     network_info: NetworkInfo,
 }
 
-// impl crate::message::signalproxy::Network for Network {
-//     type Item = VariantList;
+impl crate::message::signalproxy::Network for Network {
+    type Item = VariantList;
 
-//     fn to_network(&self) -> Self::Item {
-//         let mut res = Self::Item::new();
+    fn to_network(&self) -> Self::Item {
+        let mut res = Self::Item::new();
 
-//         res.push(Variant::ByteArray(s!("myNick")));
-//         res.push(Variant::String(self.my_nick.clone()));
-//         res.push(Variant::ByteArray(s!("latency")));
-//         res.push(Variant::i32(self.latency));
-//         res.push(Variant::ByteArray(s!("currentServer")));
-//         res.push(Variant::String(self.current_server.clone()));
-//         res.push(Variant::ByteArray(s!("isConnected")));
-//         res.push(Variant::bool(self.is_connected));
-//         res.push(Variant::ByteArray(s!("connectionState")));
-//         res.push(Variant::i32(self.connection_state.clone() as i32));
+        res.push(Variant::ByteArray(s!("myNick")));
+        res.push(Variant::String(self.my_nick.clone()));
+        res.push(Variant::ByteArray(s!("latency")));
+        res.push(Variant::i32(self.latency));
+        res.push(Variant::ByteArray(s!("currentServer")));
+        res.push(Variant::String(self.current_server.clone()));
+        res.push(Variant::ByteArray(s!("isConnected")));
+        res.push(Variant::bool(self.is_connected));
+        res.push(Variant::ByteArray(s!("connectionState")));
+        res.push(Variant::i32(self.connection_state.clone() as i32));
 
-//         res.push(Variant::ByteArray(s!("Supports")));
-//         res.push(Variant::VariantMap(
-//             self.supports
-//                 .iter()
-//                 .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
-//                 .collect(),
-//         ));
+        res.push(Variant::ByteArray(s!("Supports")));
+        res.push(Variant::VariantMap(
+            self.supports
+                .iter()
+                .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
+                .collect(),
+        ));
 
-//         res.push(Variant::ByteArray(s!("Caps")));
-//         res.push(Variant::VariantMap(
-//             self.caps
-//                 .iter()
-//                 .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
-//                 .collect(),
-//         ));
+        res.push(Variant::ByteArray(s!("Caps")));
+        res.push(Variant::VariantMap(
+            self.caps
+                .iter()
+                .map(|(k, v)| (k.clone(), Variant::String(v.clone())))
+                .collect(),
+        ));
 
-//         res.push(Variant::ByteArray(s!("CapsEnabled")));
-//         res.push(Variant::VariantList(
-//             self.caps_enabled
-//                 .iter()
-//                 .map(|v| Variant::String(v.clone()))
-//                 .collect(),
-//         ));
+        res.push(Variant::ByteArray(s!("CapsEnabled")));
+        res.push(Variant::VariantList(
+            self.caps_enabled
+                .iter()
+                .map(|v| Variant::String(v.clone()))
+                .collect(),
+        ));
 
-//         {
-//             let mut map = VariantMap::new();
+        {
+            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.insert(
+                s!("Users"),
+                Variant::VariantMap(self.irc_users.iter().fold(
+                    HashMap::new(),
+                    |mut res, (_, v)| {
+                        res.extend(v.to_network());
 
-//                         res
-//                     },
-//                 )),
-//             );
+                        res
+                    },
+                )),
+            );
 
-//             let channels = self
-//                 .irc_channels
-//                 .iter()
-//                 .fold(HashMap::new(), |mut res, (_, v)| {
-//                     res.extend(v.to_network());
+            let channels = self
+                .irc_channels
+                .iter()
+                .fold(HashMap::new(), |mut res, (_, v)| {
+                    res.extend(v.to_network());
 
-//                     res
-//                 });
+                    res
+                });
 
-//             map.insert(s!("Channels"), Variant::VariantMap(channels));
+            map.insert(s!("Channels"), Variant::VariantMap(channels));
 
-//             res.push(Variant::ByteArray(s!("IrcUsersAndChannels")));
-//             res.push(Variant::VariantMap(map));
-//         }
+            res.push(Variant::ByteArray(s!("IrcUsersAndChannels")));
+            res.push(Variant::VariantMap(map));
+        }
 
-//         res.extend(self.network_info.to_network());
+        res.extend(self.network_info.to_network());
 
-//         res
-//     }
+        res
+    }
 
-//     fn from_network(input: Self::Item) -> Self {
-//         let users_and_channels = match_variant!(
-//             input
-//                 .iter()
-//                 .nth(
-//                     input
-//                         .iter()
-//                         .position(|x| *x == Variant::ByteArray(s!("IrcUsersAndChannels")))
-//                         .unwrap()
-//                 )
-//                 .unwrap(),
-//             Variant::VariantMap
-//         );
+    fn from_network(input: &mut Self::Item) -> Self {
+        let users_and_channels = match_variant!(
+            input
+                .iter()
+                .nth(
+                    input
+                        .iter()
+                        .position(|x| *x == Variant::ByteArray(s!("IrcUsersAndChannels")))
+                        .unwrap()
+                )
+                .unwrap(),
+            Variant::VariantMap
+        );
 
-//         let res = Self {
-//             my_nick: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("myNick")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::String
-//             ),
-//             latency: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("latency")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::i32
-//             ),
-//             current_server: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("currentServer")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::String
-//             ),
-//             is_connected: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("isConnected")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::bool
-//             ),
-//             connection_state: ConnectionState::from_i32(match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("connectionState")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::i32
-//             ))
-//             .unwrap(),
-//             irc_users: match_variant!(
-//                 users_and_channels.get("Users").unwrap(),
-//                 Variant::VariantMap
-//             )
-//             .iter()
-//             .map(|(k, v)| (k, IrcUser::from_network(v))),
-//             irc_channels: match_variant!(
-//                 users_and_channels.get("Channels").unwrap(),
-//                 Variant::VariantMap
-//             )
-//             .iter()
-//             .map(|(k, v)| (k, match_variant!(v, Variant::VariantList))),
-//             supports: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("Supports")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::VariantMap
-//             )
-//             .iter()
-//             .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String)))
-//             .collect(),
-//             caps: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("Caps")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::VariantMap
-//             )
-//             .iter()
-//             .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String)))
-//             .collect(),
-//             caps_enabled: match_variant!(
-//                 input
-//                     .iter()
-//                     .nth(
-//                         input
-//                             .iter()
-//                             .position(|x| *x == Variant::ByteArray(s!("CapsEnabled")))
-//                             .unwrap()
-//                     )
-//                     .unwrap(),
-//                 Variant::VariantList
-//             )
-//             .iter()
-//             .map(|v| match_variant!(v, Variant::String))
-//             .collect(),
-//             network_info: NetworkInfo::from_network(input),
-//         };
+        let res = Self {
+            my_nick: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("myNick")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::String
+            ),
+            latency: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("latency")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::i32
+            ),
+            current_server: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("currentServer")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::String
+            ),
+            is_connected: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("isConnected")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::bool
+            ),
+            connection_state: ConnectionState::from_i32(match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("connectionState")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::i32
+            ))
+            .unwrap(),
+            irc_users: match_variant!(
+                users_and_channels.get("Users").unwrap(),
+                Variant::VariantMap
+            )
+            .iter()
+            .map(|(k, v)| (k, IrcUser::from_network(v))),
+            irc_channels: match_variant!(
+                users_and_channels.get("Channels").unwrap(),
+                Variant::VariantMap
+            )
+            .iter()
+            .map(|(k, v)| (k, match_variant!(v, Variant::VariantList))),
+            supports: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("Supports")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::VariantMap
+            )
+            .iter()
+            .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String)))
+            .collect(),
+            caps: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("Caps")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::VariantMap
+            )
+            .iter()
+            .map(|(k, v)| (k.clone(), match_variant!(v, Variant::String)))
+            .collect(),
+            caps_enabled: match_variant!(
+                input
+                    .iter()
+                    .nth(
+                        input
+                            .iter()
+                            .position(|x| *x == Variant::ByteArray(s!("CapsEnabled")))
+                            .unwrap()
+                    )
+                    .unwrap(),
+                Variant::VariantList
+            )
+            .iter()
+            .map(|v| match_variant!(v, Variant::String))
+            .collect(),
+            network_info: NetworkInfo::from_network(input),
+        };
 
-//         todo!()
-//     }
-// }
+        todo!()
+    }
+}
 
 #[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq, Network)]
diff --git a/src/message/signalproxy/objects/networkinfo.rs b/src/message/signalproxy/objects/networkinfo.rs
index a7f0a3c..e36297d 100644
--- a/src/message/signalproxy/objects/networkinfo.rs
+++ b/src/message/signalproxy/objects/networkinfo.rs
@@ -16,7 +16,7 @@ pub struct NetworkInfo {
         rename = "ServerList",
         override_type = "VariantList",
         to_map = "|server| Variant::VariantMap(server.to_network())",
-        from_map = "|server| NetworkServer::from_network(match_variant!(server, Variant::VariantMap))"
+        from_map = "|server| NetworkServer::from_network(&mut match_variant!(server, Variant::VariantMap))"
     )]
     pub server_list: Vec<NetworkServer>,
     #[network(rename = "perform")]
@@ -166,4 +166,9 @@ mod tests {
     fn networkinfo_to_network() {
         assert_eq!(get_runtime().to_network(), get_network())
     }
+
+    #[test]
+    fn networkinfo_from_network() {
+        assert_eq!(NetworkInfo::from_network(&mut get_network()), get_runtime())
+    }
 }
diff --git a/src/message/signalproxy/translation/mod.rs b/src/message/signalproxy/translation/mod.rs
index bbb8b3f..064257c 100644
--- a/src/message/signalproxy/translation/mod.rs
+++ b/src/message/signalproxy/translation/mod.rs
@@ -2,5 +2,5 @@ pub trait Network {
     type Item;
 
     fn to_network(&self) -> Self::Item;
-    fn from_network(input: Self::Item) -> Self;
+    fn from_network(input: &mut Self::Item) -> Self;
 }
diff --git a/src/primitive/bufferinfo.rs b/src/primitive/bufferinfo.rs
index 1c4e206..24080cb 100644
--- a/src/primitive/bufferinfo.rs
+++ b/src/primitive/bufferinfo.rs
@@ -42,6 +42,7 @@ impl Deserialize for BufferInfo {
 
         // There are 4 additional undocumented Bytes in the BufferInfo
         // so we start at byte 14
+        // TODO is groupid
         let (size, name) = String::parse_utf8(&b[14..])?;
 
         return Ok((
diff --git a/src/primitive/string.rs b/src/primitive/string.rs
index 590c529..7ea838d 100644
--- a/src/primitive/string.rs
+++ b/src/primitive/string.rs
@@ -10,6 +10,8 @@ use log::trace;
 use crate::util;
 use crate::{Deserialize, DeserializeUTF8, Serialize, SerializeUTF8};
 
+pub type ByteArray = String;
+
 /// We Shadow the String type here as we can only use impl on types in our own scope.
 ///
 /// Strings are serialized as an i32 for the length in bytes, then the chars represented in UTF-16 in bytes.
diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index e9e032e..8a98d59 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -12,6 +12,8 @@ use crate::{Serialize, SerializeUTF8};
 
 use crate::primitive::{BufferInfo, Date, DateTime, Message, Time, VariantList, VariantMap};
 
+use libquassel_derive::From;
+
 /// Variant represents the possible types we can receive
 ///
 /// Variant's are serizalized as the Type as a i32 and then the Type in it's own format
@@ -21,9 +23,10 @@ use crate::primitive::{BufferInfo, Date, DateTime, Message, Time, VariantList, V
 ///
 /// ByteArray is de-/serialized as a C ByteArray.
 #[allow(non_camel_case_types, dead_code)]
-#[derive(Clone, Debug, std::cmp::PartialEq)]
+#[derive(Clone, Debug, PartialEq, From)]
 pub enum Variant {
     Unknown,
+    #[from(ignore)]
     UserType(String, Vec<u8>),
     BufferInfo(BufferInfo),
     Message(Message),
@@ -33,6 +36,7 @@ pub enum Variant {
     VariantMap(VariantMap),
     VariantList(VariantList),
     String(String),
+    #[from(ignore)]
     ByteArray(String),
     StringList(StringList),
     bool(bool),