four 0.0.13

framework for creating AWS CloudFormation template
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

mod alias;
mod arn;
mod event_invoke_config;
mod function;
mod id;
mod layer_version;
mod layer_version_permission;
mod permission;
mod property;
pub mod resource;
mod url;
mod version;

pub use alias::{
    version_weight, version_weights, AliasDescription, AliasDescriptionError, AliasName,
    AliasNameError, AliasRoutingConfiguration, FunctionVersion, FunctionVersionError,
    VersionWeight,
};
pub use arn::{FunctionArn, LayerVersionArn, VersionArn};
pub use event_invoke_config::{
    DestinationConfig, MaximumEventAgeInSeconds, MaximumEventAgeInSecondsError,
    MaximumRetryAttempts, MaximumRetryAttemptsError, OnFailure, OnSuccess,
};
pub use function::{
    FunctionName, FunctionNameError, MemorySize, MemorySizeError, Timeout, TimeoutError,
};
pub use id::{LayerVersionPermissionId, UrlId};
pub use layer_version::{
    CompatibleArchitectures, CompatibleArchitecturesError, CompatibleRuntimes,
    CompatibleRuntimesError, FunctionContent, LayerName, LayerNameError, LayerVersionDescription,
    LayerVersionDescriptionError, LicenseInfo, LicenseInfoError,
};
pub use layer_version_permission::{
    GetLayerVersionAction, LayerVersionPrincipal, OrganizationId, OrganizationIdError,
};
pub use permission::{
    EventSourceToken, EventSourceTokenError, PermissionPrincipal, PrincipalOrgID,
    PrincipalOrgIDError,
};
pub use property::{
    architecture::{Architecture, Architectures},
    code::Code,
    function_name::LooseFunctionName,
    handler::{Handler, HandlerError},
    runtime::Runtime,
};
use serde::Serialize;
pub use url::{
    AuthType, Cors, Header, HeaderError, InvokeMode, MaxAge, MaxAgeError, Method, Origin,
};
pub use version::{
    RuntimePolicy, RuntimeVersionArn, RuntimeVersionArnError, VersionDescription,
    VersionDescriptionError,
};

use crate::convert::WillMappable;

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ProvisionedConcurrencyConfiguration {
    provisioned_concurrent_executions: usize,
}

impl ProvisionedConcurrencyConfiguration {
    pub fn new(executions: usize) -> Self {
        Self {
            provisioned_concurrent_executions: executions,
        }
    }
}

#[derive(Debug, Clone)]
pub enum Qualifier {
    Version(FunctionVersion),
    Alias(AliasName),
    Latest,
}

impl Serialize for Qualifier {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Qualifier::Version(x) => x.serialize(serializer),
            Qualifier::Alias(a) => a.serialize(serializer),
            Qualifier::Latest => "$LATEST".serialize(serializer),
        }
    }
}

impl WillMappable<FunctionVersion> for Qualifier {}