azure-functions-codegen 0.1.2

Code generation for writing Azure Functions in Rust.
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

mod http;
mod http_trigger;
mod timer_trigger;

pub use self::http::*;
pub use self::http_trigger::*;
pub use self::timer_trigger::*;

use proc_macro::Diagnostic;
use quote::ToTokens;
use std::collections::HashMap;
use std::convert::TryFrom;
use util::AttributeArguments;

pub type BindingFactory = fn(&AttributeArguments) -> Result<Binding, Diagnostic>;

lazy_static! {
    pub static ref TRIGGERS: HashMap<&'static str, BindingFactory> = {
        let mut map: HashMap<&'static str, BindingFactory> = HashMap::new();
        map.insert("HttpRequest", |args| {
            Ok(Binding::HttpTrigger(HttpTrigger::try_from(args)?))
        });
        map.insert("TimerInfo", |args| {
            Ok(Binding::TimerTrigger(TimerTrigger::try_from(args)?))
        });
        map
    };
    pub static ref INPUT_BINDINGS: HashMap<&'static str, BindingFactory> = {
        let map: HashMap<&'static str, BindingFactory> = HashMap::new();
        map
    };
    pub static ref INPUT_OUTPUT_BINDINGS: HashMap<&'static str, BindingFactory> = {
        let map: HashMap<&'static str, BindingFactory> = HashMap::new();
        map
    };
    pub static ref OUTPUT_BINDINGS: HashMap<&'static str, BindingFactory> = {
        let mut map: HashMap<&'static str, BindingFactory> = HashMap::new();
        map.insert("HttpResponse", |args| {
            Ok(Binding::Http(Http::try_from(args)?))
        });
        map
    };
}

#[derive(Debug)]
pub enum Binding {
    HttpTrigger(HttpTrigger),
    Http(Http),
    TimerTrigger(TimerTrigger),
}

impl Binding {
    pub fn is_trigger(&self) -> bool {
        match self {
            Binding::HttpTrigger(_) | Binding::TimerTrigger(_) => true,
            Binding::Http(_) => false,
        }
    }
}

impl ToTokens for Binding {
    fn to_tokens(&self, tokens: &mut ::proc_macro2::TokenStream) {
        match self {
            Binding::HttpTrigger(b) => quote!(
                ::azure_functions::codegen::Binding::HttpTrigger(#b)
            ).to_tokens(tokens),
            Binding::Http(b) => quote!(
                ::azure_functions::codegen::Binding::Http(#b)
            ).to_tokens(tokens),
            Binding::TimerTrigger(b) => quote!(
                ::azure_functions::codegen::Binding::TimerTrigger(#b)
            ).to_tokens(tokens),
        };
    }
}