accepts-codegen 0.0.1

Rust toolkit for composing synchronous and asynchronous acceptor pipelines
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

use quote::format_ident;
use syn::{Path, Token, parse::Parse, token::Brace};

use crate::common::syn::parsers::KeyValueMap;

use super::{ForwardSource, MutGuardErrorConfig};

#[derive(Debug, Clone)]
pub struct MutGuardConfig {
    pub guard_access_path: Path,
    pub guard_access_error: Option<MutGuardErrorConfig>,
}
impl MutGuardConfig {
    pub fn from_parts(
        guard_access_path: Path,
        guard_access_error: Option<MutGuardErrorConfig>,
    ) -> Self {
        Self {
            guard_access_path,
            guard_access_error,
        }
    }
}
impl Parse for MutGuardConfig {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let guard_access_path = input.call(Path::parse_mod_style)?;

        let guard_access_error = if input.peek(Token![<]) {
            input.parse::<Token![<]>()?;

            let guard_access_error = input.parse()?;

            input.parse::<Token![>]>()?;

            let mut option_config = if input.peek(Brace) {
                Some(input.parse::<KeyValueMap<Token![=]>>()?)
            } else {
                None
            };

            let accepts_generics_ident = if let Some(ident) =
                option_config.as_mut().map_or(Ok(None), |option_config| {
                    option_config.try_take_parse("error_accepts_generics_ident")
                })? {
                ident
            } else {
                format_ident!("AccessErrorAccepts")
            };

            let accepts_field_ident = if let Some(ident) =
                option_config.as_mut().map_or(Ok(None), |option_config| {
                    option_config.try_take_parse("error_accepts_field_ident")
                })? {
                ident
            } else {
                format_ident!("access_error_acceptor")
            };

            let forward_source = if let Some(ident) =
                option_config.as_mut().map_or(Ok(None), |option_config| {
                    option_config.try_take_parse("forward_source")
                })? {
                ident
            } else {
                ForwardSource::None
            };

            if let Some(option_config) = option_config.as_mut() {
                option_config.error_if_not_empty("unknown option")?;
            }

            let guard_access_error = MutGuardErrorConfig::from_parts(
                guard_access_error,
                accepts_generics_ident,
                accepts_field_ident,
                forward_source,
            );

            Some(guard_access_error)
        } else {
            None
        };

        Ok(Self::from_parts(guard_access_path, guard_access_error))
    }
}