rework Network derives to be more consistent

i don't even know anymore, blame past me

1 files changed, 20 insertions, 37 deletions

diff --git a/derive/src/network/list.rs b/derive/src/network/list.rs
index 0c6e626..973444e 100644
--- a/derive/src/network/list.rs
+++ b/derive/src/network/list.rs
@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 
-use super::{get_field_type, get_field_type_colon, get_field_variant_type, NetworkField};
+use super::{get_field_variant_type, NetworkField};
 
 pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
@@ -16,17 +16,14 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
                 let field_name = field.ident.as_ref().unwrap();
                 let field_type = get_field_variant_type(&field);
 
-                let field_inner = if field.network {
-                    if field.map {
-                        quote! { self.#field_name.to_network_map() }
-                    } else {
-                        match field.variant.as_ref().map_or("", |m| m.as_str()) {
-                            "VariantMap" => quote! { self.#field_name.to_network_map() },
-                            &_ => quote! { self.#field_name.to_network() },
-                        }
+                let field_inner = match field.network {
+                    crate::network::NetworkRepr::List => {
+                        quote! { libquassel::message::NetworkList::to_network_list(&self.#field_name).into() }
                     }
-                } else {
-                    quote! { self.#field_name.clone() }
+                    crate::network::NetworkRepr::Map => {
+                        quote! { libquassel::message::NetworkMap::to_network_map(&self.#field_name).into() }
+                    }
+                    crate::network::NetworkRepr::None => quote! { self.#field_name.clone().into() },
                 };
 
                 quote! {
@@ -56,49 +53,35 @@ pub(crate) fn from(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
                     None => format!("{}", field.ident.as_ref().unwrap()).into(),
                 };
 
-                let field_type = get_field_type(&field);
                 let field_variant_type = get_field_variant_type(&field);
 
-                let field_type_colon = get_field_type_colon(field_type.clone());
-
                 let extract_inner = quote! {
                     let mut i = input.iter();
                     i.position(|x| *x == libquassel::primitive::Variant::ByteArray(String::from(#field_rename)))
                         .expect(format!("failed to get field {}", #field_rename).as_str());
 
                     match i.next().expect("failed to get next field") {
-                        libquassel::primitive::Variant::#field_variant_type(var) => var.clone(),
+                        libquassel::primitive::Variant::#field_variant_type(var) => var.clone().try_into().unwrap(),
                         _ => panic!("network::list::from: wrong variant type"),
                     }
                 };
 
-                if field.network {
-                    if field.map {
-                        quote! {
-                            #field_name: #field_type_colon::from_network_map(&mut {
+                match field.network {
+                    super::NetworkRepr::List => quote! {
+                            #field_name: libquassel::message::NetworkList::from_network_list(&mut {
                                 #extract_inner
                             }),
-                        }
-                    } else {
-                        match field.variant.as_ref().map_or("", |m| m.as_str()) {
-                            "VariantMap" => quote! {
-                                #field_name: #field_type_colon::from_network_map(&mut {
-                                    #extract_inner
-                                }),
-                            },
-                            &_ => quote! {
-                                #field_name: #field_type_colon::from_network(&mut {
-                                    #extract_inner
-                                }),
-                            },
-                        }
-                    }
-                } else {
-                    quote! {
+                        },
+                    super::NetworkRepr::Map => quote! {
+                            #field_name: libquassel::message::NetworkMap::from_network_map(&mut {
+                                #extract_inner
+                            }),
+                        },
+                    super::NetworkRepr::None => quote! {
                         #field_name: {
                             #extract_inner
                         },
-                    }
+                    },
                 }
             }
         })