binwrite_derive 0.2.1

Derive macro for binwrite
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

use super::attributes::AttrSetting;
use crate::binwrite_endian::Endian;
use proc_macro2::TokenStream;
use std::num::NonZeroUsize;

pub enum Action {
    Default,
    CutomerWriter(TokenStream),
}

#[derive(Default)]
pub struct GenOptions {
    pub pad_before: Option<NonZeroUsize>,
    pub pad_after: Option<NonZeroUsize>,
    pub align_before: Option<NonZeroUsize>,
    pub align_after: Option<NonZeroUsize>,
    pub preprocessor: Option<TokenStream>,
    pub postprocessor: Option<TokenStream>,
}

#[derive(Default)]
pub struct OptionalWriterOption {
    pub endian: Option<Endian>
}

pub struct WriteInstructions(pub Action, pub OptionalWriterOption, pub GenOptions);

impl WriteInstructions {
    pub fn try_from(settings: &[AttrSetting]) -> Option<WriteInstructions> {
        let mut action: Action = Action::Default;
        let mut writer_option = OptionalWriterOption::default();
        let mut gen_options = GenOptions::default();
        for setting in settings.iter() {
            match setting {
                AttrSetting::Endian(endian) => {
                    writer_option.endian = Some(*endian);
                }
                AttrSetting::With(writer_func) => {
                    action = Action::CutomerWriter(writer_func.clone());
                }
                AttrSetting::Preprocessor(preprocessor) => {
                    gen_options.preprocessor = Some(preprocessor.clone());
                }
                AttrSetting::Postprocessor(preprocessor) => {
                    gen_options.postprocessor = Some(preprocessor.clone());
                }
                AttrSetting::AlignBefore(pad) => {
                    gen_options.align_before = NonZeroUsize::new(*pad);
                }
                AttrSetting::AlignAfter(pad) => {
                    gen_options.align_after = NonZeroUsize::new(*pad);
                }
                AttrSetting::PadBefore(pad) => {
                    gen_options.pad_before = NonZeroUsize::new(*pad);
                }
                AttrSetting::PadAfter(pad) => {
                    gen_options.pad_after = NonZeroUsize::new(*pad);
                }
                AttrSetting::Ignore => {
                    None?
                }
            }
        }
        
        Some(WriteInstructions(action, writer_option, gen_options))
    }
}