Struct aws_sdk_ec2::model::SnapshotTierStatus

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

Provides information about a snapshot's storage tier.

Implementations

impl SnapshotTierStatus

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

The ID of the snapshot.

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

The ID of the volume from which the snapshot was created.

pub fn status(&self) -> Option<&SnapshotState>

The state of the snapshot.

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

The ID of the Amazon Web Services account that owns the snapshot.

pub fn tags(&self) -> Option<&[Tag]>

The tags that are assigned to the snapshot.

pub fn storage_tier(&self) -> Option<&StorageTier>

The storage tier in which the snapshot is stored. standard indicates that the snapshot is stored in the standard snapshot storage tier and that it is ready for use. archive indicates that the snapshot is currently archived and that it must be restored before it can be used.

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

The date and time when the last archive or restore process was started.

pub fn last_tiering_progress(&self) -> Option<i32>

The progress of the last archive or restore process, as a percentage.

pub fn last_tiering_operation_status(&self) -> Option<&TieringOperationStatus>

The status of the last archive or restore process.

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

A message describing the status of the last archive or restore process.

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

The date and time when the last archive process was completed.

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

Only for archived snapshots that are temporarily restored. Indicates the date and time when a temporarily restored snapshot will be automatically re-archived.

impl SnapshotTierStatus

pub fn builder() -> Builder

Creates a new builder-style object to manufacture SnapshotTierStatus.

Examples found in repository

src/xml_deser.rs (line 49758)

pub fn deser_structure_crate_model_snapshot_tier_status(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::SnapshotTierStatus, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::SnapshotTierStatus::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("snapshotId") /* SnapshotId com.amazonaws.ec2#SnapshotTierStatus$SnapshotId */ =>  {
                let var_2322 =
                    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_snapshot_id(var_2322);
            }
            ,
            s if s.matches("volumeId") /* VolumeId com.amazonaws.ec2#SnapshotTierStatus$VolumeId */ =>  {
                let var_2323 =
                    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_volume_id(var_2323);
            }
            ,
            s if s.matches("status") /* Status com.amazonaws.ec2#SnapshotTierStatus$Status */ =>  {
                let var_2324 =
                    Some(
                        Result::<crate::model::SnapshotState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::SnapshotState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_status(var_2324);
            }
            ,
            s if s.matches("ownerId") /* OwnerId com.amazonaws.ec2#SnapshotTierStatus$OwnerId */ =>  {
                let var_2325 =
                    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_owner_id(var_2325);
            }
            ,
            s if s.matches("tagSet") /* Tags com.amazonaws.ec2#SnapshotTierStatus$Tags */ =>  {
                let var_2326 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_2326);
            }
            ,
            s if s.matches("storageTier") /* StorageTier com.amazonaws.ec2#SnapshotTierStatus$StorageTier */ =>  {
                let var_2327 =
                    Some(
                        Result::<crate::model::StorageTier, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::StorageTier::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_storage_tier(var_2327);
            }
            ,
            s if s.matches("lastTieringStartTime") /* LastTieringStartTime com.amazonaws.ec2#SnapshotTierStatus$LastTieringStartTime */ =>  {
                let var_2328 =
                    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.ec2#MillisecondDateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_last_tiering_start_time(var_2328);
            }
            ,
            s if s.matches("lastTieringProgress") /* LastTieringProgress com.amazonaws.ec2#SnapshotTierStatus$LastTieringProgress */ =>  {
                let var_2329 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_last_tiering_progress(var_2329);
            }
            ,
            s if s.matches("lastTieringOperationStatus") /* LastTieringOperationStatus com.amazonaws.ec2#SnapshotTierStatus$LastTieringOperationStatus */ =>  {
                let var_2330 =
                    Some(
                        Result::<crate::model::TieringOperationStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TieringOperationStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_last_tiering_operation_status(var_2330);
            }
            ,
            s if s.matches("lastTieringOperationStatusDetail") /* LastTieringOperationStatusDetail com.amazonaws.ec2#SnapshotTierStatus$LastTieringOperationStatusDetail */ =>  {
                let var_2331 =
                    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_last_tiering_operation_status_detail(var_2331);
            }
            ,
            s if s.matches("archivalCompleteTime") /* ArchivalCompleteTime com.amazonaws.ec2#SnapshotTierStatus$ArchivalCompleteTime */ =>  {
                let var_2332 =
                    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.ec2#MillisecondDateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_archival_complete_time(var_2332);
            }
            ,
            s if s.matches("restoreExpiryTime") /* RestoreExpiryTime com.amazonaws.ec2#SnapshotTierStatus$RestoreExpiryTime */ =>  {
                let var_2333 =
                    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.ec2#MillisecondDateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_restore_expiry_time(var_2333);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for SnapshotTierStatus

fn clone(&self) -> SnapshotTierStatus

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SnapshotTierStatus

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

Formats the value using the given formatter.

impl PartialEq<SnapshotTierStatus> for SnapshotTierStatus

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