io_self_derive 0.2.0

Derive macros for the io_self crate.
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use darling::{FromDeriveInput, FromField, FromVariant};
use proc_macro2::{self, TokenStream};
use quote::{quote, ToTokens};
use std::str::FromStr;
use syn::Type;

#[derive(FromDeriveInput, Default)]
#[darling(default, attributes(io_self), forward_attrs(allow, doc, cfg))]
pub struct Opts {
    endian: Option<String>,
    tag: Option<String>,
    length_prefix: Option<String>,
}

impl Opts {
    pub fn length_prefix_type(&self) -> Option<Type> {
        let prefix = TokenStream::from_str(self.length_prefix.as_ref()?)
            .expect("Unable to tokenize enum length prefix");
        Some(syn::parse2(prefix).expect("Expected type"))
    }

    pub fn endianness(&self) -> Option<Endian> {
        match self.endian.as_ref()?.to_ascii_lowercase().as_ref() {
            "little" | "le" | "l" => Some(Endian::Little),
            "big" | "be" | "b" => Some(Endian::Big),
            x => panic!("Unknown endian format: {:?}", x),
        }
    }

    pub fn trait_usage(&self, read: bool) -> TokenStream {
        match (read, self.endianness()) {
            (false, None) => quote!(::io_self::WriteSelf),
            (true, None) => quote!(::io_self::ReadSelf),
            (false, Some(Endian::Little)) => quote!(
                ::io_self::derive_util::WriteSelfEndian<::io_self::derive_util::LittleEndian>
            ),
            (true, Some(Endian::Little)) => {
                quote!(::io_self::derive_util::ReadSelfEndian<::io_self::derive_util::LittleEndian>)
            }
            (false, Some(Endian::Big)) => {
                quote!(::io_self::derive_util::WriteSelfEndian<::io_self::derive_util::BigEndian>)
            }
            (true, Some(Endian::Big)) => {
                quote!(::io_self::derive_util::ReadSelfEndian<::io_self::derive_util::BigEndian>)
            }
        }
    }

    pub fn tag_type(&self) -> Option<Type> {
        let tag = TokenStream::from_str(self.tag.as_ref()?).unwrap();
        Some(syn::parse2(tag).expect("Expected type"))
    }
}

#[derive(FromVariant, Default)]
#[darling(default, attributes(io_self), forward_attrs(allow, doc, cfg))]
pub struct VariantOpts {
    tag: String,
}

impl VariantOpts {
    pub fn tag(&self) -> TokenStream {
        TokenStream::from_str(&self.tag).unwrap()
    }
}

#[derive(Copy, Clone)]
pub enum Endian {
    Little,
    Big,
}

impl ToTokens for Endian {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        match self {
            Endian::Little => tokens.extend(quote!(io_self::derive_util::byteorder::LittleEndian)),
            Endian::Big => tokens.extend(quote!(io_self::derive_util::byteorder::BigEndian)),
        }
    }
}

#[derive(FromField, Default)]
#[darling(default, attributes(io_self), forward_attrs(allow, doc, cfg))]
pub struct FieldOpts {
    length_prefix: Option<String>,
}

impl FieldOpts {
    pub fn length_prefix_type(&self) -> Option<Type> {
        let prefix = TokenStream::from_str(self.length_prefix.as_ref()?)
            .expect("Unable to tokenize field length prefix");
        Some(syn::parse2(prefix).expect("Expected type"))
    }
}