indicator_macros 0.4.4

Abstractions for stream aggregation, we call them `Indicator` s.
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

use proc_macro2::Span;
use syn::{
    parse::{Parse, ParseStream},
    punctuated::Punctuated,
    Expr, ExprAssign, ExprPath, Ident, Result, Token, Type, TypePath,
};

pub(crate) struct OperatorArgs {
    pub(crate) input_type: Type,
    pub(crate) generate_out: Option<GenerateOut>,
}

#[derive(Clone, Copy)]
pub(crate) enum GenerateOut {
    Out,
    WithData,
    Data,
}

impl Parse for OperatorArgs {
    fn parse(input: ParseStream) -> Result<Self> {
        let args = Punctuated::<Args, Token![,]>::parse_terminated(input)?;
        let mut input_type = None;
        let mut generate_out = None;
        for arg in args {
            match arg {
                Args::GenerateOut(out) => generate_out = Some(out),
                Args::InputType(ty) => input_type = Some(ty),
            }
        }
        let input_type = input_type
            .ok_or_else(|| syn::Error::new(Span::call_site(), "`input` argument is required"))?;
        Ok(Self {
            input_type,
            generate_out,
        })
    }
}

enum Args {
    InputType(Type),
    GenerateOut(GenerateOut),
}

fn get_ident(expr: &Expr) -> Result<&Ident> {
    let Expr::Path(ExprPath { path, .. }) = expr else {
        return Err(syn::Error::new(
            Span::call_site(),
            "Expecting an identifier",
        ));
    };
    let ident = path
        .get_ident()
        .ok_or_else(|| syn::Error::new(Span::call_site(), "Expecting an identifier"))?;
    Ok(ident)
}

impl Parse for Args {
    fn parse(input: ParseStream) -> Result<Self> {
        let expr: Expr = input.parse()?;
        match expr {
            Expr::Assign(ExprAssign { left, right, .. }) => {
                let ident = get_ident(&left)?;
                if ident == "input" {
                    let Expr::Path(ExprPath { path, .. }) = *right else {
                        return Err(syn::Error::new(Span::call_site(), "Expecting a type"));
                    };
                    Ok(Self::InputType(Type::Path(TypePath { qself: None, path })))
                } else {
                    Err(syn::Error::new(
                        ident.span(),
                        format!("Unknown argument: `{ident}`, expecting `input = T`"),
                    ))
                }
            }
            expr => {
                let ident = get_ident(&expr)?;
                match ident.to_string().as_str() {
                    "generate_out" => Ok(Self::GenerateOut(GenerateOut::Out)),
                    "generate_data" => Ok(Self::GenerateOut(GenerateOut::Data)),
                    "generate_out_with_data" => Ok(Self::GenerateOut(GenerateOut::WithData)),
                    _ => Err(syn::Error::new(
                        ident.span(),
                        format!("Unknown argument: `{ident}`, expecting `generate_out`, `generate_out_data` or `generate_out_with_data`"),
                    )),
                }
            }
        }
    }
}