Struct ParameterMap 

pub struct ParameterMap(pub BTreeMap<ParameterKey, ParameterValue>);

Tuple Fields

0: BTreeMap<ParameterKey, ParameterValue>

Implementations

impl ParameterMap

pub fn new() -> Self

pub fn parse<'a>( values: impl IntoIterator<Item = &'a Parameter>, ) -> Result<ParameterMap, String>

Parse a parameter vector into a parameter map

Examples

No duplicates

let parameters = vec![
    Parameter {
        key: ParameterKey("key-a".to_string()),
        value: ParameterValue("value-a".to_string()),
    },
    Parameter {
        key: ParameterKey("key-b".to_string()),
        value: ParameterValue("value-b".to_string()),
    },
];

assert_eq!(
    Ok(ParameterMap(std::collections::BTreeMap::from([
        (
            ParameterKey(String::from("key-a")),
            ParameterValue(String::from("value-a"))
        ),
        (
            ParameterKey(String::from("key-b")),
            ParameterValue(String::from("value-b"))
        ),
    ]))),
    ParameterMap::parse(&parameters)
);

Present duplicate, errors on first duplicate

let parameters = vec![
    Parameter {
        key: ParameterKey("key-a".to_string()),
        value: ParameterValue("value-a".to_string()),
    },
    Parameter {
        key: ParameterKey("key-a".to_string()),
        value: ParameterValue("value-a".to_string()),
    },
    Parameter {
        key: ParameterKey("key-b".to_string()),
        value: ParameterValue("value-b".to_string()),
    },
    Parameter {
        key: ParameterKey("key-b".to_string()),
        value: ParameterValue("value-b".to_string()),
    },
];

assert_eq!(
    Err(String::from(
        "Parameter key: key-a is present multiple times"
    )),
    ParameterMap::parse(&parameters)
);

pub fn merge(&self, other: &Self) -> Self

Merge parameter map into receiver

Examples

let original = ParameterMap(std::collections::BTreeMap::from([
    (
        ParameterKey(String::from("key-a")),
        ParameterValue(String::from("value-a")),
    ),
    (
        ParameterKey(String::from("key-b")),
        ParameterValue(String::from("value-b1")),
    ),
]));

let extra = ParameterMap(std::collections::BTreeMap::from([
    (
        ParameterKey(String::from("key-b")),
        ParameterValue(String::from("value-b2")),
    ),
    (
        ParameterKey(String::from("key-c")),
        ParameterValue(String::from("value-c")),
    ),
]));

assert_eq!(
    ParameterMap(std::collections::BTreeMap::from([
        (
            ParameterKey(String::from("key-a")),
            ParameterValue(String::from("value-a"))
        ),
        (
            ParameterKey(String::from("key-b")),
            ParameterValue(String::from("value-b2"))
        ),
        (
            ParameterKey(String::from("key-c")),
            ParameterValue(String::from("value-c"))
        ),
    ])),
    original.merge(&extra)
)

pub fn to_create_parameters(&self) -> Vec<Parameter>

To create parameters

Examples

assert_eq!(
    vec![
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-a")
            .parameter_value("value-a")
            .build(),
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-b")
            .parameter_value("value-b")
            .build(),
    ],
    ParameterMap(std::collections::BTreeMap::from([
        (
            ParameterKey(String::from("key-a")),
            ParameterValue(String::from("value-a"))
        ),
        (
            ParameterKey(String::from("key-b")),
            ParameterValue(String::from("value-b"))
        ),
    ]))
    .to_create_parameters(),
)

pub fn to_parameter_update_parameters( &self, existing_stack: &Stack, ) -> Vec<Parameter>

To parameter update parameters

Examples

Some updates

let existing_stack = aws_sdk_cloudformation::types::Stack::builder()
    .set_parameters(Some(vec![
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-a")
            .parameter_value("value-a1")
            .build(),
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-b")
            .parameter_value("value-b1")
            .build(),
    ]))
    .build();

assert_eq!(
    vec![
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-a")
            .use_previous_value(true)
            .build(),
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-b")
            .parameter_value("value-b2")
            .build(),
    ],
    ParameterMap(std::collections::BTreeMap::from([(
        ParameterKey(String::from("key-b")),
        ParameterValue(String::from("value-b2"))
    ),]))
    .to_parameter_update_parameters(&existing_stack),
)

pub fn to_template_update_parameters( &self, template_parameter_keys: &ParameterKeys, existing_stack_parameter_keys: &ParameterKeys, ) -> Vec<Parameter>

To template update parameters

Examples

One parameter unchanged key-a, one parameter changed key-b, one parameter is probably new in the template key-c.

let template_parameter_keys = ParameterKeys::from([
    ParameterKey(String::from("key-a")),
    ParameterKey(String::from("key-b")),
    ParameterKey(String::from("key-c")),
]);

let existing_stack_parameter_keys = ParameterKeys::from([ParameterKey(String::from("key-a"))]);

assert_eq!(
    vec![
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-a")
            .use_previous_value(true)
            .build(),
        aws_sdk_cloudformation::types::Parameter::builder()
            .parameter_key("key-b")
            .parameter_value("value-b")
            .build(),
    ],
    ParameterMap(std::collections::BTreeMap::from([(
        ParameterKey(String::from("key-b")),
        ParameterValue(String::from("value-b"))
    ),]))
    .to_template_update_parameters(&template_parameter_keys, &existing_stack_parameter_keys),
)

pub fn to_parameter_keys(&self) -> ParameterKeys

To parameter keys

Examples

let template = Template::Plain {
    name: "example".into(),
    rendered: TemplateRendered {
        body: "ununsed".into(),
        format: TemplateFormat::JSON,
    },
    parameter_keys: ParameterKeys::from([ParameterKey(String::from("key-a"))]),
};

assert_eq!(
    ParameterKeys::from([
        ParameterKey(String::from("key-a")),
        ParameterKey(String::from("key-b")),
    ]),
    ParameterMap(std::collections::BTreeMap::from([
        (
            ParameterKey(String::from("key-a")),
            ParameterValue(String::from("value-a"))
        ),
        (
            ParameterKey(String::from("key-b")),
            ParameterValue(String::from("value-b"))
        ),
    ]))
    .to_parameter_keys()
)

Trait Implementations

impl Debug for ParameterMap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ParameterMap

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for ParameterMap

fn eq(&self, other: &ParameterMap) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ParameterMap