Struct aws_sdk_ec2::model::VpnConnectionOptions

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

Describes VPN connection options.

Implementations

impl VpnConnectionOptions

pub fn enable_acceleration(&self) -> Option<bool>

Indicates whether acceleration is enabled for the VPN connection.

pub fn static_routes_only(&self) -> Option<bool>

Indicates whether the VPN connection uses static routes only. Static routes must be used for devices that don't support BGP.

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

The IPv4 CIDR on the customer gateway (on-premises) side of the VPN connection.

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

The IPv4 CIDR on the Amazon Web Services side of the VPN connection.

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

The IPv6 CIDR on the customer gateway (on-premises) side of the VPN connection.

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

The IPv6 CIDR on the Amazon Web Services side of the VPN connection.

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

The type of IPv4 address assigned to the outside interface of the customer gateway.

Valid values: PrivateIpv4 | PublicIpv4

Default: PublicIpv4

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

The transit gateway attachment ID in use for the VPN tunnel.

pub fn tunnel_inside_ip_version(&self) -> Option<&TunnelInsideIpVersion>

Indicates whether the VPN tunnels process IPv4 or IPv6 traffic.

pub fn tunnel_options(&self) -> Option<&[TunnelOption]>

Indicates the VPN tunnel options.

impl VpnConnectionOptions

pub fn builder() -> Builder

Creates a new builder-style object to manufacture VpnConnectionOptions.

Examples found in repository

src/xml_deser.rs (line 42234)

pub fn deser_structure_crate_model_vpn_connection_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::VpnConnectionOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::VpnConnectionOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("enableAcceleration") /* EnableAcceleration com.amazonaws.ec2#VpnConnectionOptions$EnableAcceleration */ =>  {
                let var_1807 =
                    Some(
                         {
                            <bool 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 (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_enable_acceleration(var_1807);
            }
            ,
            s if s.matches("staticRoutesOnly") /* StaticRoutesOnly com.amazonaws.ec2#VpnConnectionOptions$StaticRoutesOnly */ =>  {
                let var_1808 =
                    Some(
                         {
                            <bool 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 (boolean: `com.amazonaws.ec2#Boolean`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_static_routes_only(var_1808);
            }
            ,
            s if s.matches("localIpv4NetworkCidr") /* LocalIpv4NetworkCidr com.amazonaws.ec2#VpnConnectionOptions$LocalIpv4NetworkCidr */ =>  {
                let var_1809 =
                    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_local_ipv4_network_cidr(var_1809);
            }
            ,
            s if s.matches("remoteIpv4NetworkCidr") /* RemoteIpv4NetworkCidr com.amazonaws.ec2#VpnConnectionOptions$RemoteIpv4NetworkCidr */ =>  {
                let var_1810 =
                    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_remote_ipv4_network_cidr(var_1810);
            }
            ,
            s if s.matches("localIpv6NetworkCidr") /* LocalIpv6NetworkCidr com.amazonaws.ec2#VpnConnectionOptions$LocalIpv6NetworkCidr */ =>  {
                let var_1811 =
                    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_local_ipv6_network_cidr(var_1811);
            }
            ,
            s if s.matches("remoteIpv6NetworkCidr") /* RemoteIpv6NetworkCidr com.amazonaws.ec2#VpnConnectionOptions$RemoteIpv6NetworkCidr */ =>  {
                let var_1812 =
                    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_remote_ipv6_network_cidr(var_1812);
            }
            ,
            s if s.matches("outsideIpAddressType") /* OutsideIpAddressType com.amazonaws.ec2#VpnConnectionOptions$OutsideIpAddressType */ =>  {
                let var_1813 =
                    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_outside_ip_address_type(var_1813);
            }
            ,
            s if s.matches("transportTransitGatewayAttachmentId") /* TransportTransitGatewayAttachmentId com.amazonaws.ec2#VpnConnectionOptions$TransportTransitGatewayAttachmentId */ =>  {
                let var_1814 =
                    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_transport_transit_gateway_attachment_id(var_1814);
            }
            ,
            s if s.matches("tunnelInsideIpVersion") /* TunnelInsideIpVersion com.amazonaws.ec2#VpnConnectionOptions$TunnelInsideIpVersion */ =>  {
                let var_1815 =
                    Some(
                        Result::<crate::model::TunnelInsideIpVersion, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::TunnelInsideIpVersion::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_tunnel_inside_ip_version(var_1815);
            }
            ,
            s if s.matches("tunnelOptionSet") /* TunnelOptions com.amazonaws.ec2#VpnConnectionOptions$TunnelOptions */ =>  {
                let var_1816 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tunnel_options_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tunnel_options(var_1816);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for VpnConnectionOptions

fn clone(&self) -> VpnConnectionOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VpnConnectionOptions

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

Formats the value using the given formatter.

impl PartialEq<VpnConnectionOptions> for VpnConnectionOptions

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