Struct aws_sdk_ec2::model::TransitGatewayOptions

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

Describes the options for a transit gateway.

Implementations

impl TransitGatewayOptions

pub fn amazon_side_asn(&self) -> Option<i64>

A private Autonomous System Number (ASN) for the Amazon side of a BGP session. The range is 64512 to 65534 for 16-bit ASNs and 4200000000 to 4294967294 for 32-bit ASNs.

pub fn transit_gateway_cidr_blocks(&self) -> Option<&[String]>

The transit gateway CIDR blocks.

pub fn auto_accept_shared_attachments(
    &self
) -> Option<&AutoAcceptSharedAttachmentsValue>

Indicates whether attachment requests are automatically accepted.

pub fn default_route_table_association(
    &self
) -> Option<&DefaultRouteTableAssociationValue>

Indicates whether resource attachments are automatically associated with the default association route table.

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

The ID of the default association route table.

pub fn default_route_table_propagation(
    &self
) -> Option<&DefaultRouteTablePropagationValue>

Indicates whether resource attachments automatically propagate routes to the default propagation route table.

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

The ID of the default propagation route table.

pub fn vpn_ecmp_support(&self) -> Option<&VpnEcmpSupportValue>

Indicates whether Equal Cost Multipath Protocol support is enabled.

pub fn dns_support(&self) -> Option<&DnsSupportValue>

Indicates whether DNS support is enabled.

pub fn multicast_support(&self) -> Option<&MulticastSupportValue>

Indicates whether multicast is enabled on the transit gateway

impl TransitGatewayOptions

pub fn builder() -> Builder

Creates a new builder-style object to manufacture TransitGatewayOptions.

Examples found in repository

src/xml_deser.rs (line 41535)

pub fn deser_structure_crate_model_transit_gateway_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::TransitGatewayOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::TransitGatewayOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("amazonSideAsn") /* AmazonSideAsn com.amazonaws.ec2#TransitGatewayOptions$AmazonSideAsn */ =>  {
                let var_1772 =
                    Some(
                         {
                            <i64 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 (long: `com.amazonaws.ec2#Long`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_amazon_side_asn(var_1772);
            }
            ,
            s if s.matches("transitGatewayCidrBlocks") /* TransitGatewayCidrBlocks com.amazonaws.ec2#TransitGatewayOptions$TransitGatewayCidrBlocks */ =>  {
                let var_1773 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_value_string_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_transit_gateway_cidr_blocks(var_1773);
            }
            ,
            s if s.matches("autoAcceptSharedAttachments") /* AutoAcceptSharedAttachments com.amazonaws.ec2#TransitGatewayOptions$AutoAcceptSharedAttachments */ =>  {
                let var_1774 =
                    Some(
                        Result::<crate::model::AutoAcceptSharedAttachmentsValue, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::AutoAcceptSharedAttachmentsValue::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_auto_accept_shared_attachments(var_1774);
            }
            ,
            s if s.matches("defaultRouteTableAssociation") /* DefaultRouteTableAssociation com.amazonaws.ec2#TransitGatewayOptions$DefaultRouteTableAssociation */ =>  {
                let var_1775 =
                    Some(
                        Result::<crate::model::DefaultRouteTableAssociationValue, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::DefaultRouteTableAssociationValue::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_default_route_table_association(var_1775);
            }
            ,
            s if s.matches("associationDefaultRouteTableId") /* AssociationDefaultRouteTableId com.amazonaws.ec2#TransitGatewayOptions$AssociationDefaultRouteTableId */ =>  {
                let var_1776 =
                    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_association_default_route_table_id(var_1776);
            }
            ,
            s if s.matches("defaultRouteTablePropagation") /* DefaultRouteTablePropagation com.amazonaws.ec2#TransitGatewayOptions$DefaultRouteTablePropagation */ =>  {
                let var_1777 =
                    Some(
                        Result::<crate::model::DefaultRouteTablePropagationValue, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::DefaultRouteTablePropagationValue::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_default_route_table_propagation(var_1777);
            }
            ,
            s if s.matches("propagationDefaultRouteTableId") /* PropagationDefaultRouteTableId com.amazonaws.ec2#TransitGatewayOptions$PropagationDefaultRouteTableId */ =>  {
                let var_1778 =
                    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_propagation_default_route_table_id(var_1778);
            }
            ,
            s if s.matches("vpnEcmpSupport") /* VpnEcmpSupport com.amazonaws.ec2#TransitGatewayOptions$VpnEcmpSupport */ =>  {
                let var_1779 =
                    Some(
                        Result::<crate::model::VpnEcmpSupportValue, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::VpnEcmpSupportValue::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_vpn_ecmp_support(var_1779);
            }
            ,
            s if s.matches("dnsSupport") /* DnsSupport com.amazonaws.ec2#TransitGatewayOptions$DnsSupport */ =>  {
                let var_1780 =
                    Some(
                        Result::<crate::model::DnsSupportValue, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::DnsSupportValue::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_dns_support(var_1780);
            }
            ,
            s if s.matches("multicastSupport") /* MulticastSupport com.amazonaws.ec2#TransitGatewayOptions$MulticastSupport */ =>  {
                let var_1781 =
                    Some(
                        Result::<crate::model::MulticastSupportValue, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::MulticastSupportValue::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_multicast_support(var_1781);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for TransitGatewayOptions

fn clone(&self) -> TransitGatewayOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TransitGatewayOptions

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

Formats the value using the given formatter.

impl PartialEq<TransitGatewayOptions> for TransitGatewayOptions

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