Struct aws_sdk_ec2::model::AvailabilityZone

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

Describes Availability Zones, Local Zones, and Wavelength Zones.

Implementations

impl AvailabilityZone

pub fn state(&self) -> Option<&AvailabilityZoneState>

The state of the Availability Zone, Local Zone, or Wavelength Zone. This value is always available.

pub fn opt_in_status(&self) -> Option<&AvailabilityZoneOptInStatus>

For Availability Zones, this parameter always has the value of opt-in-not-required.

For Local Zones and Wavelength Zones, this parameter is the opt-in status. The possible values are opted-in, and not-opted-in.

pub fn messages(&self) -> Option<&[AvailabilityZoneMessage]>

Any messages about the Availability Zone, Local Zone, or Wavelength Zone.

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

The name of the Region.

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

The name of the Availability Zone, Local Zone, or Wavelength Zone.

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

The ID of the Availability Zone, Local Zone, or Wavelength Zone.

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

For Availability Zones, this parameter has the same value as the Region name.

For Local Zones, the name of the associated group, for example us-west-2-lax-1.

For Wavelength Zones, the name of the associated group, for example us-east-1-wl1-bos-wlz-1.

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

The name of the network border group.

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

The type of zone. The valid values are availability-zone, local-zone, and wavelength-zone.

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

The name of the zone that handles some of the Local Zone or Wavelength Zone control plane operations, such as API calls.

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

The ID of the zone that handles some of the Local Zone or Wavelength Zone control plane operations, such as API calls.

impl AvailabilityZone

pub fn builder() -> Builder

Creates a new builder-style object to manufacture AvailabilityZone.

Examples found in repository

src/xml_deser.rs (line 43059)

pub fn deser_structure_crate_model_availability_zone(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::AvailabilityZone, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::AvailabilityZone::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("zoneState") /* State com.amazonaws.ec2#AvailabilityZone$State */ =>  {
                let var_1853 =
                    Some(
                        Result::<crate::model::AvailabilityZoneState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::AvailabilityZoneState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_state(var_1853);
            }
            ,
            s if s.matches("optInStatus") /* OptInStatus com.amazonaws.ec2#AvailabilityZone$OptInStatus */ =>  {
                let var_1854 =
                    Some(
                        Result::<crate::model::AvailabilityZoneOptInStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::AvailabilityZoneOptInStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_opt_in_status(var_1854);
            }
            ,
            s if s.matches("messageSet") /* Messages com.amazonaws.ec2#AvailabilityZone$Messages */ =>  {
                let var_1855 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_availability_zone_message_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_messages(var_1855);
            }
            ,
            s if s.matches("regionName") /* RegionName com.amazonaws.ec2#AvailabilityZone$RegionName */ =>  {
                let var_1856 =
                    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_region_name(var_1856);
            }
            ,
            s if s.matches("zoneName") /* ZoneName com.amazonaws.ec2#AvailabilityZone$ZoneName */ =>  {
                let var_1857 =
                    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_zone_name(var_1857);
            }
            ,
            s if s.matches("zoneId") /* ZoneId com.amazonaws.ec2#AvailabilityZone$ZoneId */ =>  {
                let var_1858 =
                    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_zone_id(var_1858);
            }
            ,
            s if s.matches("groupName") /* GroupName com.amazonaws.ec2#AvailabilityZone$GroupName */ =>  {
                let var_1859 =
                    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_group_name(var_1859);
            }
            ,
            s if s.matches("networkBorderGroup") /* NetworkBorderGroup com.amazonaws.ec2#AvailabilityZone$NetworkBorderGroup */ =>  {
                let var_1860 =
                    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_network_border_group(var_1860);
            }
            ,
            s if s.matches("zoneType") /* ZoneType com.amazonaws.ec2#AvailabilityZone$ZoneType */ =>  {
                let var_1861 =
                    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_zone_type(var_1861);
            }
            ,
            s if s.matches("parentZoneName") /* ParentZoneName com.amazonaws.ec2#AvailabilityZone$ParentZoneName */ =>  {
                let var_1862 =
                    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_parent_zone_name(var_1862);
            }
            ,
            s if s.matches("parentZoneId") /* ParentZoneId com.amazonaws.ec2#AvailabilityZone$ParentZoneId */ =>  {
                let var_1863 =
                    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_parent_zone_id(var_1863);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for AvailabilityZone

fn clone(&self) -> AvailabilityZone

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AvailabilityZone

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

Formats the value using the given formatter.

impl PartialEq<AvailabilityZone> for AvailabilityZone

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