Struct aws_sdk_ec2::model::peering_connection_options::Builder

pub struct Builder { /* private fields */ }

A builder for PeeringConnectionOptions.

Implementations

impl Builder

pub fn allow_dns_resolution_from_remote_vpc(self, input: bool) -> Self

If true, the public DNS hostnames of instances in the specified VPC resolve to private IP addresses when queried from instances in the peer VPC.

pub fn set_allow_dns_resolution_from_remote_vpc(
    self,
    input: Option<bool>
) -> Self

If true, the public DNS hostnames of instances in the specified VPC resolve to private IP addresses when queried from instances in the peer VPC.

Examples found in repository

src/xml_deser.rs (line 38091)

pub fn deser_structure_crate_model_peering_connection_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::PeeringConnectionOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::PeeringConnectionOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("allowDnsResolutionFromRemoteVpc") /* AllowDnsResolutionFromRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowDnsResolutionFromRemoteVpc */ =>  {
                let var_1602 =
                    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_allow_dns_resolution_from_remote_vpc(var_1602);
            }
            ,
            s if s.matches("allowEgressFromLocalClassicLinkToRemoteVpc") /* AllowEgressFromLocalClassicLinkToRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalClassicLinkToRemoteVpc */ =>  {
                let var_1603 =
                    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_allow_egress_from_local_classic_link_to_remote_vpc(var_1603);
            }
            ,
            s if s.matches("allowEgressFromLocalVpcToRemoteClassicLink") /* AllowEgressFromLocalVpcToRemoteClassicLink com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalVpcToRemoteClassicLink */ =>  {
                let var_1604 =
                    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_allow_egress_from_local_vpc_to_remote_classic_link(var_1604);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn allow_egress_from_local_classic_link_to_remote_vpc(
    self,
    input: bool
) -> Self

If true, enables outbound communication from an EC2-Classic instance that's linked to a local VPC using ClassicLink to instances in a peer VPC.

pub fn set_allow_egress_from_local_classic_link_to_remote_vpc(
    self,
    input: Option<bool>
) -> Self

If true, enables outbound communication from an EC2-Classic instance that's linked to a local VPC using ClassicLink to instances in a peer VPC.

Examples found in repository

src/xml_deser.rs (line 38106)

pub fn deser_structure_crate_model_peering_connection_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::PeeringConnectionOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::PeeringConnectionOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("allowDnsResolutionFromRemoteVpc") /* AllowDnsResolutionFromRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowDnsResolutionFromRemoteVpc */ =>  {
                let var_1602 =
                    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_allow_dns_resolution_from_remote_vpc(var_1602);
            }
            ,
            s if s.matches("allowEgressFromLocalClassicLinkToRemoteVpc") /* AllowEgressFromLocalClassicLinkToRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalClassicLinkToRemoteVpc */ =>  {
                let var_1603 =
                    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_allow_egress_from_local_classic_link_to_remote_vpc(var_1603);
            }
            ,
            s if s.matches("allowEgressFromLocalVpcToRemoteClassicLink") /* AllowEgressFromLocalVpcToRemoteClassicLink com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalVpcToRemoteClassicLink */ =>  {
                let var_1604 =
                    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_allow_egress_from_local_vpc_to_remote_classic_link(var_1604);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn allow_egress_from_local_vpc_to_remote_classic_link(
    self,
    input: bool
) -> Self

If true, enables outbound communication from instances in a local VPC to an EC2-Classic instance that's linked to a peer VPC using ClassicLink.

pub fn set_allow_egress_from_local_vpc_to_remote_classic_link(
    self,
    input: Option<bool>
) -> Self

If true, enables outbound communication from instances in a local VPC to an EC2-Classic instance that's linked to a peer VPC using ClassicLink.

Examples found in repository

src/xml_deser.rs (line 38121)

pub fn deser_structure_crate_model_peering_connection_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::PeeringConnectionOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::PeeringConnectionOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("allowDnsResolutionFromRemoteVpc") /* AllowDnsResolutionFromRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowDnsResolutionFromRemoteVpc */ =>  {
                let var_1602 =
                    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_allow_dns_resolution_from_remote_vpc(var_1602);
            }
            ,
            s if s.matches("allowEgressFromLocalClassicLinkToRemoteVpc") /* AllowEgressFromLocalClassicLinkToRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalClassicLinkToRemoteVpc */ =>  {
                let var_1603 =
                    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_allow_egress_from_local_classic_link_to_remote_vpc(var_1603);
            }
            ,
            s if s.matches("allowEgressFromLocalVpcToRemoteClassicLink") /* AllowEgressFromLocalVpcToRemoteClassicLink com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalVpcToRemoteClassicLink */ =>  {
                let var_1604 =
                    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_allow_egress_from_local_vpc_to_remote_classic_link(var_1604);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

pub fn build(self) -> PeeringConnectionOptions

Consumes the builder and constructs a PeeringConnectionOptions.

Examples found in repository

src/xml_deser.rs (line 38127)

pub fn deser_structure_crate_model_peering_connection_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::PeeringConnectionOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::PeeringConnectionOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("allowDnsResolutionFromRemoteVpc") /* AllowDnsResolutionFromRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowDnsResolutionFromRemoteVpc */ =>  {
                let var_1602 =
                    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_allow_dns_resolution_from_remote_vpc(var_1602);
            }
            ,
            s if s.matches("allowEgressFromLocalClassicLinkToRemoteVpc") /* AllowEgressFromLocalClassicLinkToRemoteVpc com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalClassicLinkToRemoteVpc */ =>  {
                let var_1603 =
                    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_allow_egress_from_local_classic_link_to_remote_vpc(var_1603);
            }
            ,
            s if s.matches("allowEgressFromLocalVpcToRemoteClassicLink") /* AllowEgressFromLocalVpcToRemoteClassicLink com.amazonaws.ec2#PeeringConnectionOptions$AllowEgressFromLocalVpcToRemoteClassicLink */ =>  {
                let var_1604 =
                    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_allow_egress_from_local_vpc_to_remote_classic_link(var_1604);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Builder

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

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.

impl PartialEq<Builder> for Builder

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