Enum ExpString 

pub enum ExpString {
    Base64(Box<ExpString>),
    FindInMap {
        map_name: MapName,
        top_level_key: Box<ExpString>,
        second_level_key: String,
    },
    GetAtt {
        logical_resource_name: LogicalResourceName,
        attribute_name: AttributeName,
    },
    If {
        condition_name: ConditionName,
        true_branch: Box<ExpString>,
        else_branch: Box<ExpString>,
    },
    ImportValue(OutputExportName),
    Join {
        delimiter: String,
        values: Vec<ExpString>,
    },
    Literal(String),
    Ref(LogicalResourceName),
    Select {
        index: u8,
        values: Box<ExpStringList>,
    },
    Split {
        delimiter: String,
        source: Box<ExpString>,
    },
    Sub {
        pattern: String,
    },
    AwsAccountId,
    AwsPartition,
    AwsRegion,
    AwsStackId,
    AwsStackName,
    AwsUrlSuffix,
}

Variants

Base64(Box<ExpString>)

FindInMap

Fields

map_name: MapName

top_level_key: Box<ExpString>

second_level_key: String

GetAtt

Fields

logical_resource_name: LogicalResourceName

attribute_name: AttributeName

If

Fields

condition_name: ConditionName

true_branch: Box<ExpString>

else_branch: Box<ExpString>

ImportValue(OutputExportName)

Join

Fields

delimiter: String

values: Vec<ExpString>

Literal(String)

Ref(LogicalResourceName)

Select

Fields

index: u8

values: Box<ExpStringList>

Split

Fields

delimiter: String

source: Box<ExpString>

Sub

Fields

pattern: String

AwsAccountId

AwsPartition

AwsRegion

AwsStackId

AwsStackName

AwsUrlSuffix

Implementations

impl ExpString

pub fn base64(self) -> ExpString

Trait Implementations

impl Clone for ExpString

fn clone(&self) -> ExpString

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExpString

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

Formats the value using the given formatter.

impl FnFindInMap for ExpString

fn fn_find_in_map( map_name: impl Into<MapName>, top_level_key: impl Into<ExpString>, second_level_key: impl Into<String>, ) -> Self

Creates a find in map expression using Fn::FindInMap

impl FnIf for ExpString

fn fn_if( condition_name: impl Into<ConditionName>, true_branch: impl Into<Self>, else_branch: impl Into<Self>, ) -> Self

Creates a conditional expression using Fn::If

impl FnSelect for ExpString

type ValueList = ExpStringList

The type representing a list of values that can be selected from

fn fn_select(index: u8, values: Self::ValueList) -> Self

Creates a select expression using Fn::Select

impl From<&LogicalResourceName> for ExpString

fn from(value: &LogicalResourceName) -> Self

Converts to this type from the input type.

impl From<&ParameterKey> for ExpString

fn from(value: &ParameterKey) -> Self

Converts to this type from the input type.

impl From<&str> for ExpString

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<LogicalResourceName> for ExpString

fn from(value: LogicalResourceName) -> Self

Converts to this type from the input type.

impl From<ParameterKey> for ExpString

fn from(value: ParameterKey) -> Self

Converts to this type from the input type.

impl PartialEq for ExpString

fn eq(&self, other: &ExpString) -> 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 Serialize for ExpString

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl ToValue for ExpString

fn to_value(&self) -> Value

Render expression to CF template value^

Panics

On internal errors/bugs, there is no public API that allows to construct values that panic on this call.

Examples

Fn::Base64

assert_eq!(
  json!({"Fn::Base64":"some-literal"}),
  ExpString::from("some-literal").base64().to_value()
)

Fn::If

assert_eq!(
  json!({"Fn::If":["condition-name",{"Ref":"resource-a"},{"Ref":"resource-b"}]}),
  ExpString::If{
    condition_name: "condition-name".into(),
    true_branch: Box::new(LogicalResourceName::from("resource-a").into()),
    else_branch: Box::new(LogicalResourceName::from("resource-b").into()),
  }.to_value()
)

Ref

let logical_resource_name = LogicalResourceName::from("some-logical-resource-name");
let reference : ExpString = logical_resource_name.into();

assert_eq!(
  json!({"Ref":"some-logical-resource-name"}),
  reference.to_value()
)

Fn::GetAtt

assert_eq!(
  json!({"Fn::GetAtt":["some-logical-resource-name", "some-attribute-name"]}),
  ExpString::GetAtt{
    logical_resource_name: "some-logical-resource-name".into(),
    attribute_name: "some-attribute-name".into()
  }.to_value()
)

String Literal

let exp : ExpString = "some-literal".into();

assert_eq!(json!{"some-literal"}, exp.to_value())

Fn::Join

assert_eq!(
  json!({"Fn::Join":[',', [{"Ref": "some-logical-resource-name"}, "some-literal"]]}),
  ExpString::Join{
    delimiter: String::from(","),
    values: vec![
      LogicalResourceName::from("some-logical-resource-name").into(),
      "some-literal".into()
    ]
  }.to_value()
)

impl Eq for ExpString

impl StructuralPartialEq for ExpString