Struct aws_sdk_cloudformation::model::ResourceChange

#[non_exhaustive]
pub struct ResourceChange { /* private fields */ }

The ResourceChange structure describes the resource and the action that CloudFormation will perform on it if you execute this change set.

Implementations

impl ResourceChange

pub fn action(&self) -> Option<&ChangeAction>

The action that CloudFormation takes on the resource, such as Add (adds a new resource), Modify (changes a resource), Remove (deletes a resource), Import (imports a resource), or Dynamic (exact action for the resource can't be determined).

pub fn logical_resource_id(&self) -> Option<&str>

The resource's logical ID, which is defined in the stack's template.

pub fn physical_resource_id(&self) -> Option<&str>

The resource's physical ID (resource name). Resources that you are adding don't have physical IDs because they haven't been created.

pub fn resource_type(&self) -> Option<&str>

The type of CloudFormation resource, such as AWS::S3::Bucket.

pub fn replacement(&self) -> Option<&Replacement>

For the Modify action, indicates whether CloudFormation will replace the resource by creating a new one and deleting the old one. This value depends on the value of the RequiresRecreation property in the ResourceTargetDefinition structure. For example, if the RequiresRecreation field is Always and the Evaluation field is Static, Replacement is True. If the RequiresRecreation field is Always and the Evaluation field is Dynamic, Replacement is Conditionally.

If you have multiple changes with different RequiresRecreation values, the Replacement value depends on the change with the most impact. A RequiresRecreation value of Always has the most impact, followed by Conditionally, and then Never.

pub fn scope(&self) -> Option<&[ResourceAttribute]>

For the Modify action, indicates which resource attribute is triggering this update, such as a change in the resource attribute's Metadata, Properties, or Tags.

pub fn details(&self) -> Option<&[ResourceChangeDetail]>

For the Modify action, a list of ResourceChangeDetail structures that describes the changes that CloudFormation will make to the resource.

pub fn change_set_id(&self) -> Option<&str>

The change set ID of the nested change set.

pub fn module_info(&self) -> Option<&ModuleInfo>

Contains information about the module from which the resource was created, if the resource was created from a module included in the stack template.

impl ResourceChange

pub fn builder() -> Builder

Creates a new builder-style object to manufacture ResourceChange.

Examples found in repository

src/xml_deser.rs (line 9593)

pub fn deser_structure_crate_model_resource_change(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::ResourceChange, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::ResourceChange::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("Action") /* Action com.amazonaws.cloudformation#ResourceChange$Action */ =>  {
                let var_449 =
                    Some(
                        Result::<crate::model::ChangeAction, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ChangeAction::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_action(var_449);
            }
            ,
            s if s.matches("LogicalResourceId") /* LogicalResourceId com.amazonaws.cloudformation#ResourceChange$LogicalResourceId */ =>  {
                let var_450 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_logical_resource_id(var_450);
            }
            ,
            s if s.matches("PhysicalResourceId") /* PhysicalResourceId com.amazonaws.cloudformation#ResourceChange$PhysicalResourceId */ =>  {
                let var_451 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_physical_resource_id(var_451);
            }
            ,
            s if s.matches("ResourceType") /* ResourceType com.amazonaws.cloudformation#ResourceChange$ResourceType */ =>  {
                let var_452 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_resource_type(var_452);
            }
            ,
            s if s.matches("Replacement") /* Replacement com.amazonaws.cloudformation#ResourceChange$Replacement */ =>  {
                let var_453 =
                    Some(
                        Result::<crate::model::Replacement, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::Replacement::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_replacement(var_453);
            }
            ,
            s if s.matches("Scope") /* Scope com.amazonaws.cloudformation#ResourceChange$Scope */ =>  {
                let var_454 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_cloudformation_scope(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_scope(var_454);
            }
            ,
            s if s.matches("Details") /* Details com.amazonaws.cloudformation#ResourceChange$Details */ =>  {
                let var_455 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_cloudformation_resource_change_details(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_details(var_455);
            }
            ,
            s if s.matches("ChangeSetId") /* ChangeSetId com.amazonaws.cloudformation#ResourceChange$ChangeSetId */ =>  {
                let var_456 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_change_set_id(var_456);
            }
            ,
            s if s.matches("ModuleInfo") /* ModuleInfo com.amazonaws.cloudformation#ResourceChange$ModuleInfo */ =>  {
                let var_457 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_module_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_module_info(var_457);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for ResourceChange

fn clone(&self) -> ResourceChange

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ResourceChange

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

Formats the value using the given formatter.

impl PartialEq<ResourceChange> for ResourceChange

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for ResourceChange