derive-into 0.2.4

A Rust derive macro for easily creating conversions between structs and enums
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

pub(super) fn is_surrounding_type(ty: &syn::Type, surrounding_type: &'static str) -> bool {
    extract_inner_type(ty, surrounding_type).is_some()
}

pub(crate) fn extract_inner_type<'a>(
    ty: &'a syn::Type,
    surrounding_type: &str,
) -> Option<&'a syn::Type> {
    if let syn::Type::Path(type_path) = ty {
        if type_path.path.segments.len() == 1 {
            let segment = &type_path.path.segments[0];
            if segment.ident == surrounding_type {
                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
                    if let Some(syn::GenericArgument::Type(inner_ty)) = args.args.first() {
                        return Some(inner_ty);
                    }
                }
            }
        }
    }
    None
}

pub(crate) fn extract_hashmap_inner_types(ty: &syn::Type) -> Option<(&syn::Type, &syn::Type)> {
    if let syn::Type::Path(type_path) = ty {
        if type_path.path.segments.len() == 1 {
            let segment = &type_path.path.segments[0];
            if segment.ident == "HashMap" {
                if let syn::PathArguments::AngleBracketed(args) = &segment.arguments {
                    let mut types = args.args.iter().filter_map(|arg| {
                        if let syn::GenericArgument::Type(ty) = arg {
                            Some(ty)
                        } else {
                            None
                        }
                    });
                    if let (Some(key_ty), Some(val_ty)) = (types.next(), types.next()) {
                        return Some((key_ty, val_ty));
                    }
                }
            }
        }
    }
    None
}