Struct aws_sdk_ec2::model::ServiceConfiguration

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

Describes a service configuration for a VPC endpoint service.

Implementations

impl ServiceConfiguration

pub fn service_type(&self) -> Option<&[ServiceTypeDetail]>

The type of service.

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

The ID of the service.

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

The name of the service.

pub fn service_state(&self) -> Option<&ServiceState>

The service state.

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

The Availability Zones in which the service is available.

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

Indicates whether requests from other Amazon Web Services accounts to create an endpoint to the service must first be accepted.

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

Indicates whether the service manages its VPC endpoints. Management of the service VPC endpoints using the VPC endpoint API is restricted.

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

The Amazon Resource Names (ARNs) of the Network Load Balancers for the service.

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

The Amazon Resource Names (ARNs) of the Gateway Load Balancers for the service.

pub fn supported_ip_address_types(&self) -> Option<&[ServiceConnectivityType]>

The supported IP address types.

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

The DNS names for the service.

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

The private DNS name for the service.

pub fn private_dns_name_configuration(
    &self
) -> Option<&PrivateDnsNameConfiguration>

Information about the endpoint service private DNS name configuration.

pub fn payer_responsibility(&self) -> Option<&PayerResponsibility>

The payer responsibility.

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

Any tags assigned to the service.

impl ServiceConfiguration

pub fn builder() -> Builder

Creates a new builder-style object to manufacture ServiceConfiguration.

Examples found in repository

src/xml_deser.rs (line 31895)

pub fn deser_structure_crate_model_service_configuration(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::ServiceConfiguration, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::ServiceConfiguration::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("serviceType") /* ServiceType com.amazonaws.ec2#ServiceConfiguration$ServiceType */ =>  {
                let var_1421 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_service_type_detail_set(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_service_type(var_1421);
            }
            ,
            s if s.matches("serviceId") /* ServiceId com.amazonaws.ec2#ServiceConfiguration$ServiceId */ =>  {
                let var_1422 =
                    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_service_id(var_1422);
            }
            ,
            s if s.matches("serviceName") /* ServiceName com.amazonaws.ec2#ServiceConfiguration$ServiceName */ =>  {
                let var_1423 =
                    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_service_name(var_1423);
            }
            ,
            s if s.matches("serviceState") /* ServiceState com.amazonaws.ec2#ServiceConfiguration$ServiceState */ =>  {
                let var_1424 =
                    Some(
                        Result::<crate::model::ServiceState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_state(var_1424);
            }
            ,
            s if s.matches("availabilityZoneSet") /* AvailabilityZones com.amazonaws.ec2#ServiceConfiguration$AvailabilityZones */ =>  {
                let var_1425 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_value_string_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_availability_zones(var_1425);
            }
            ,
            s if s.matches("acceptanceRequired") /* AcceptanceRequired com.amazonaws.ec2#ServiceConfiguration$AcceptanceRequired */ =>  {
                let var_1426 =
                    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_acceptance_required(var_1426);
            }
            ,
            s if s.matches("managesVpcEndpoints") /* ManagesVpcEndpoints com.amazonaws.ec2#ServiceConfiguration$ManagesVpcEndpoints */ =>  {
                let var_1427 =
                    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_manages_vpc_endpoints(var_1427);
            }
            ,
            s if s.matches("networkLoadBalancerArnSet") /* NetworkLoadBalancerArns com.amazonaws.ec2#ServiceConfiguration$NetworkLoadBalancerArns */ =>  {
                let var_1428 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_value_string_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_network_load_balancer_arns(var_1428);
            }
            ,
            s if s.matches("gatewayLoadBalancerArnSet") /* GatewayLoadBalancerArns com.amazonaws.ec2#ServiceConfiguration$GatewayLoadBalancerArns */ =>  {
                let var_1429 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_value_string_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_gateway_load_balancer_arns(var_1429);
            }
            ,
            s if s.matches("supportedIpAddressTypeSet") /* SupportedIpAddressTypes com.amazonaws.ec2#ServiceConfiguration$SupportedIpAddressTypes */ =>  {
                let var_1430 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_supported_ip_address_types(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_supported_ip_address_types(var_1430);
            }
            ,
            s if s.matches("baseEndpointDnsNameSet") /* BaseEndpointDnsNames com.amazonaws.ec2#ServiceConfiguration$BaseEndpointDnsNames */ =>  {
                let var_1431 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_value_string_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_base_endpoint_dns_names(var_1431);
            }
            ,
            s if s.matches("privateDnsName") /* PrivateDnsName com.amazonaws.ec2#ServiceConfiguration$PrivateDnsName */ =>  {
                let var_1432 =
                    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_private_dns_name(var_1432);
            }
            ,
            s if s.matches("privateDnsNameConfiguration") /* PrivateDnsNameConfiguration com.amazonaws.ec2#ServiceConfiguration$PrivateDnsNameConfiguration */ =>  {
                let var_1433 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_private_dns_name_configuration(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_private_dns_name_configuration(var_1433);
            }
            ,
            s if s.matches("payerResponsibility") /* PayerResponsibility com.amazonaws.ec2#ServiceConfiguration$PayerResponsibility */ =>  {
                let var_1434 =
                    Some(
                        Result::<crate::model::PayerResponsibility, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::PayerResponsibility::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_payer_responsibility(var_1434);
            }
            ,
            s if s.matches("tagSet") /* Tags com.amazonaws.ec2#ServiceConfiguration$Tags */ =>  {
                let var_1435 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_1435);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for ServiceConfiguration

fn clone(&self) -> ServiceConfiguration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ServiceConfiguration

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

Formats the value using the given formatter.

impl PartialEq<ServiceConfiguration> for ServiceConfiguration

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