Struct aws_sdk_elasticache::model::CacheNodeUpdateStatus

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

The status of the service update on the cache node

Implementations

impl CacheNodeUpdateStatus

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

The node ID of the cache cluster

pub fn node_update_status(&self) -> Option<&NodeUpdateStatus>

The update status of the node

pub fn node_deletion_date(&self) -> Option<&DateTime>

The deletion date of the node

pub fn node_update_start_date(&self) -> Option<&DateTime>

The start date of the update for a node

pub fn node_update_end_date(&self) -> Option<&DateTime>

The end date of the update for a node

pub fn node_update_initiated_by(&self) -> Option<&NodeUpdateInitiatedBy>

Reflects whether the update was initiated by the customer or automatically applied

pub fn node_update_initiated_date(&self) -> Option<&DateTime>

The date when the update is triggered

pub fn node_update_status_modified_date(&self) -> Option<&DateTime>

The date when the NodeUpdateStatus was last modified>

impl CacheNodeUpdateStatus

pub fn builder() -> Builder

Creates a new builder-style object to manufacture CacheNodeUpdateStatus.

Examples found in repository

src/xml_deser.rs (line 11839)

pub fn deser_structure_crate_model_cache_node_update_status(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::CacheNodeUpdateStatus, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::CacheNodeUpdateStatus::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("CacheNodeId") /* CacheNodeId com.amazonaws.elasticache#CacheNodeUpdateStatus$CacheNodeId */ =>  {
                let var_511 =
                    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_cache_node_id(var_511);
            }
            ,
            s if s.matches("NodeUpdateStatus") /* NodeUpdateStatus com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeUpdateStatus */ =>  {
                let var_512 =
                    Some(
                        Result::<crate::model::NodeUpdateStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::NodeUpdateStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_node_update_status(var_512);
            }
            ,
            s if s.matches("NodeDeletionDate") /* NodeDeletionDate com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeDeletionDate */ =>  {
                let var_513 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_node_deletion_date(var_513);
            }
            ,
            s if s.matches("NodeUpdateStartDate") /* NodeUpdateStartDate com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeUpdateStartDate */ =>  {
                let var_514 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_node_update_start_date(var_514);
            }
            ,
            s if s.matches("NodeUpdateEndDate") /* NodeUpdateEndDate com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeUpdateEndDate */ =>  {
                let var_515 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_node_update_end_date(var_515);
            }
            ,
            s if s.matches("NodeUpdateInitiatedBy") /* NodeUpdateInitiatedBy com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeUpdateInitiatedBy */ =>  {
                let var_516 =
                    Some(
                        Result::<crate::model::NodeUpdateInitiatedBy, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::NodeUpdateInitiatedBy::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_node_update_initiated_by(var_516);
            }
            ,
            s if s.matches("NodeUpdateInitiatedDate") /* NodeUpdateInitiatedDate com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeUpdateInitiatedDate */ =>  {
                let var_517 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_node_update_initiated_date(var_517);
            }
            ,
            s if s.matches("NodeUpdateStatusModifiedDate") /* NodeUpdateStatusModifiedDate com.amazonaws.elasticache#CacheNodeUpdateStatus$NodeUpdateStatusModifiedDate */ =>  {
                let var_518 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_node_update_status_modified_date(var_518);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for CacheNodeUpdateStatus

fn clone(&self) -> CacheNodeUpdateStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CacheNodeUpdateStatus

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

Formats the value using the given formatter.

impl PartialEq<CacheNodeUpdateStatus> for CacheNodeUpdateStatus

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