Struct aws_sdk_elasticache::model::NodeGroupMemberUpdateStatus

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

The status of the service update on the node group member

Implementations

impl NodeGroupMemberUpdateStatus

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

The cache cluster ID

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 NodeGroupMemberUpdateStatus

pub fn builder() -> Builder

Creates a new builder-style object to manufacture NodeGroupMemberUpdateStatus.

Examples found in repository

src/xml_deser.rs (line 12171)

pub fn deser_structure_crate_model_node_group_member_update_status(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::NodeGroupMemberUpdateStatus, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::NodeGroupMemberUpdateStatus::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("CacheClusterId") /* CacheClusterId com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$CacheClusterId */ =>  {
                let var_527 =
                    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_cluster_id(var_527);
            }
            ,
            s if s.matches("CacheNodeId") /* CacheNodeId com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$CacheNodeId */ =>  {
                let var_528 =
                    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_528);
            }
            ,
            s if s.matches("NodeUpdateStatus") /* NodeUpdateStatus com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeUpdateStatus */ =>  {
                let var_529 =
                    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_529);
            }
            ,
            s if s.matches("NodeDeletionDate") /* NodeDeletionDate com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeDeletionDate */ =>  {
                let var_530 =
                    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_530);
            }
            ,
            s if s.matches("NodeUpdateStartDate") /* NodeUpdateStartDate com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeUpdateStartDate */ =>  {
                let var_531 =
                    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_531);
            }
            ,
            s if s.matches("NodeUpdateEndDate") /* NodeUpdateEndDate com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeUpdateEndDate */ =>  {
                let var_532 =
                    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_532);
            }
            ,
            s if s.matches("NodeUpdateInitiatedBy") /* NodeUpdateInitiatedBy com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeUpdateInitiatedBy */ =>  {
                let var_533 =
                    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_533);
            }
            ,
            s if s.matches("NodeUpdateInitiatedDate") /* NodeUpdateInitiatedDate com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeUpdateInitiatedDate */ =>  {
                let var_534 =
                    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_534);
            }
            ,
            s if s.matches("NodeUpdateStatusModifiedDate") /* NodeUpdateStatusModifiedDate com.amazonaws.elasticache#NodeGroupMemberUpdateStatus$NodeUpdateStatusModifiedDate */ =>  {
                let var_535 =
                    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_535);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for NodeGroupMemberUpdateStatus

fn clone(&self) -> NodeGroupMemberUpdateStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeGroupMemberUpdateStatus

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

Formats the value using the given formatter.

impl PartialEq<NodeGroupMemberUpdateStatus> for NodeGroupMemberUpdateStatus

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