Enum aws_sdk_appmesh::model::IpPreference

#[non_exhaustive]
pub enum IpPreference {
    IPv4Only,
    IPv4Preferred,
    IPv6Only,
    IPv6Preferred,
    Unknown(UnknownVariantValue),
}

When writing a match expression against IpPreference, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Here is an example of how you can make a match expression forward-compatible:

# let ippreference = unimplemented!();
match ippreference {
    IpPreference::IPv4Only => { /* ... */ },
    IpPreference::IPv4Preferred => { /* ... */ },
    IpPreference::IPv6Only => { /* ... */ },
    IpPreference::IPv6Preferred => { /* ... */ },
    other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
    _ => { /* ... */ },
}

The above code demonstrates that when ippreference represents NewFeature, the execution path will lead to the second last match arm, even though the enum does not contain a variant IpPreference::NewFeature in the current version of SDK. The reason is that the variable other, created by the @ operator, is bound to IpPreference::Unknown(UnknownVariantValue("NewFeature".to_owned())) and calling as_str on it yields "NewFeature". This match expression is forward-compatible when executed with a newer version of SDK where the variant IpPreference::NewFeature is defined. Specifically, when ippreference represents NewFeature, the execution path will hit the second last match arm as before by virtue of calling as_str on IpPreference::NewFeature also yielding "NewFeature".

Explicitly matching on the Unknown variant should be avoided for two reasons:

• The inner data UnknownVariantValue is opaque, and no further information can be extracted.
• It might inadvertently shadow other intended match arms.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

IPv4Only

IPv4Preferred

IPv6Only

IPv6Preferred

Unknown(UnknownVariantValue)

Unknown contains new variants that have been added since this code was generated.

Implementations

impl IpPreference

pub fn as_str(&self) -> &str

Returns the &str value of the enum member.

Examples found in repository

src/model.rs (line 819)

    fn as_ref(&self) -> &str {
        self.as_str()
    }

src/json_ser.rs (line 697)

pub fn serialize_structure_crate_model_mesh_service_discovery(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::MeshServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_144) = &input.ip_preference {
        object.key("ipPreference").string(var_144.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_145) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_146 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_http_route_match(
            &mut object_146,
            var_145,
        )?;
        object_146.finish();
    }
    if let Some(var_147) = &input.action {
        #[allow(unused_mut)]
        let mut object_148 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_http_route_action(
            &mut object_148,
            var_147,
        )?;
        object_148.finish();
    }
    if let Some(var_149) = &input.retry_policy {
        #[allow(unused_mut)]
        let mut object_150 = object.key("retryPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_http_retry_policy(
            &mut object_150,
            var_149,
        )?;
        object_150.finish();
    }
    if let Some(var_151) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_152 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_http_timeout(&mut object_152, var_151)?;
        object_152.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_153) = &input.action {
        #[allow(unused_mut)]
        let mut object_154 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_route_action(
            &mut object_154,
            var_153,
        )?;
        object_154.finish();
    }
    if let Some(var_155) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_156 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_timeout(&mut object_156, var_155)?;
        object_156.finish();
    }
    if let Some(var_157) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_158 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_tcp_route_match(&mut object_158, var_157)?;
        object_158.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_159) = &input.action {
        #[allow(unused_mut)]
        let mut object_160 = object.key("action").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_route_action(
            &mut object_160,
            var_159,
        )?;
        object_160.finish();
    }
    if let Some(var_161) = &input.r#match {
        #[allow(unused_mut)]
        let mut object_162 = object.key("match").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_route_match(
            &mut object_162,
            var_161,
        )?;
        object_162.finish();
    }
    if let Some(var_163) = &input.retry_policy {
        #[allow(unused_mut)]
        let mut object_164 = object.key("retryPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_retry_policy(
            &mut object_164,
            var_163,
        )?;
        object_164.finish();
    }
    if let Some(var_165) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_166 = object.key("timeout").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_timeout(&mut object_166, var_165)?;
        object_166.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_backend_defaults(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayBackendDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_167) = &input.client_policy {
        #[allow(unused_mut)]
        let mut object_168 = object.key("clientPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_client_policy(
            &mut object_168,
            var_167,
        )?;
        object_168.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_169) = &input.health_check {
        #[allow(unused_mut)]
        let mut object_170 = object.key("healthCheck").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_health_check_policy(
            &mut object_170,
            var_169,
        )?;
        object_170.finish();
    }
    if let Some(var_171) = &input.port_mapping {
        #[allow(unused_mut)]
        let mut object_172 = object.key("portMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_port_mapping(
            &mut object_172,
            var_171,
        )?;
        object_172.finish();
    }
    if let Some(var_173) = &input.tls {
        #[allow(unused_mut)]
        let mut object_174 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls(
            &mut object_174,
            var_173,
        )?;
        object_174.finish();
    }
    if let Some(var_175) = &input.connection_pool {
        #[allow(unused_mut)]
        let mut object_176 = object.key("connectionPool").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_connection_pool(
            &mut object_176,
            var_175,
        )?;
        object_176.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_logging(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayLogging,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_177) = &input.access_log {
        #[allow(unused_mut)]
        let mut object_178 = object.key("accessLog").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_access_log(
            &mut object_178,
            var_177,
        )?;
        object_178.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_service_discovery(
    object_116: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::ServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::ServiceDiscovery::Dns(inner) => {
            #[allow(unused_mut)]
            let mut object_179 = object_116.key("dns").start_object();
            crate::json_ser::serialize_structure_crate_model_dns_service_discovery(
                &mut object_179,
                inner,
            )?;
            object_179.finish();
        }
        crate::model::ServiceDiscovery::AwsCloudMap(inner) => {
            #[allow(unused_mut)]
            let mut object_180 = object_116.key("awsCloudMap").start_object();
            crate::json_ser::serialize_structure_crate_model_aws_cloud_map_service_discovery(
                &mut object_180,
                inner,
            )?;
            object_180.finish();
        }
        crate::model::ServiceDiscovery::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "ServiceDiscovery",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Listener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_181) = &input.port_mapping {
        #[allow(unused_mut)]
        let mut object_182 = object.key("portMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_port_mapping(&mut object_182, var_181)?;
        object_182.finish();
    }
    if let Some(var_183) = &input.tls {
        #[allow(unused_mut)]
        let mut object_184 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_listener_tls(&mut object_184, var_183)?;
        object_184.finish();
    }
    if let Some(var_185) = &input.health_check {
        #[allow(unused_mut)]
        let mut object_186 = object.key("healthCheck").start_object();
        crate::json_ser::serialize_structure_crate_model_health_check_policy(
            &mut object_186,
            var_185,
        )?;
        object_186.finish();
    }
    if let Some(var_187) = &input.timeout {
        #[allow(unused_mut)]
        let mut object_188 = object.key("timeout").start_object();
        crate::json_ser::serialize_union_crate_model_listener_timeout(&mut object_188, var_187)?;
        object_188.finish();
    }
    if let Some(var_189) = &input.outlier_detection {
        #[allow(unused_mut)]
        let mut object_190 = object.key("outlierDetection").start_object();
        crate::json_ser::serialize_structure_crate_model_outlier_detection(
            &mut object_190,
            var_189,
        )?;
        object_190.finish();
    }
    if let Some(var_191) = &input.connection_pool {
        #[allow(unused_mut)]
        let mut object_192 = object.key("connectionPool").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_node_connection_pool(
            &mut object_192,
            var_191,
        )?;
        object_192.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_backend(
    object_124: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Backend,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::Backend::VirtualService(inner) => {
            #[allow(unused_mut)]
            let mut object_193 = object_124.key("virtualService").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_service_backend(
                &mut object_193,
                inner,
            )?;
            object_193.finish();
        }
        crate::model::Backend::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant("Backend"),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_backend_defaults(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::BackendDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_194) = &input.client_policy {
        #[allow(unused_mut)]
        let mut object_195 = object.key("clientPolicy").start_object();
        crate::json_ser::serialize_structure_crate_model_client_policy(&mut object_195, var_194)?;
        object_195.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_logging(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::Logging,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_196) = &input.access_log {
        #[allow(unused_mut)]
        let mut object_197 = object.key("accessLog").start_object();
        crate::json_ser::serialize_union_crate_model_access_log(&mut object_197, var_196)?;
        object_197.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_router_listener(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualRouterListener,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_198) = &input.port_mapping {
        #[allow(unused_mut)]
        let mut object_199 = object.key("portMapping").start_object();
        crate::json_ser::serialize_structure_crate_model_port_mapping(&mut object_199, var_198)?;
        object_199.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_service_provider(
    object_134: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualServiceProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualServiceProvider::VirtualNode(inner) => {
            #[allow(unused_mut)]
            let mut object_200 = object_134.key("virtualNode").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_node_service_provider(
                &mut object_200,
                inner,
            )?;
            object_200.finish();
        }
        crate::model::VirtualServiceProvider::VirtualRouter(inner) => {
            #[allow(unused_mut)]
            let mut object_201 = object_134.key("virtualRouter").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_router_service_provider(
                &mut object_201,
                inner,
            )?;
            object_201.finish();
        }
        crate::model::VirtualServiceProvider::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualServiceProvider",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_202) = &input.prefix {
        object.key("prefix").string(var_202.as_str());
    }
    if let Some(var_203) = &input.path {
        #[allow(unused_mut)]
        let mut object_204 = object.key("path").start_object();
        crate::json_ser::serialize_structure_crate_model_http_path_match(&mut object_204, var_203)?;
        object_204.finish();
    }
    if let Some(var_205) = &input.query_parameters {
        let mut array_206 = object.key("queryParameters").start_array();
        for item_207 in var_205 {
            {
                #[allow(unused_mut)]
                let mut object_208 = array_206.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_query_parameter(
                    &mut object_208,
                    item_207,
                )?;
                object_208.finish();
            }
        }
        array_206.finish();
    }
    if let Some(var_209) = &input.method {
        object.key("method").string(var_209.as_str());
    }
    if let Some(var_210) = &input.hostname {
        #[allow(unused_mut)]
        let mut object_211 = object.key("hostname").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_hostname_match(
            &mut object_211,
            var_210,
        )?;
        object_211.finish();
    }
    if let Some(var_212) = &input.headers {
        let mut array_213 = object.key("headers").start_array();
        for item_214 in var_212 {
            {
                #[allow(unused_mut)]
                let mut object_215 = array_213.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_gateway_route_header(
                    &mut object_215,
                    item_214,
                )?;
                object_215.finish();
            }
        }
        array_213.finish();
    }
    if let Some(var_216) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_216).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_gateway_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpGatewayRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_217) = &input.target {
        #[allow(unused_mut)]
        let mut object_218 = object.key("target").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_target(
            &mut object_218,
            var_217,
        )?;
        object_218.finish();
    }
    if let Some(var_219) = &input.rewrite {
        #[allow(unused_mut)]
        let mut object_220 = object.key("rewrite").start_object();
        crate::json_ser::serialize_structure_crate_model_http_gateway_route_rewrite(
            &mut object_220,
            var_219,
        )?;
        object_220.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_221) = &input.service_name {
        object.key("serviceName").string(var_221.as_str());
    }
    if let Some(var_222) = &input.hostname {
        #[allow(unused_mut)]
        let mut object_223 = object.key("hostname").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_hostname_match(
            &mut object_223,
            var_222,
        )?;
        object_223.finish();
    }
    if let Some(var_224) = &input.metadata {
        let mut array_225 = object.key("metadata").start_array();
        for item_226 in var_224 {
            {
                #[allow(unused_mut)]
                let mut object_227 = array_225.value().start_object();
                crate::json_ser::serialize_structure_crate_model_grpc_gateway_route_metadata(
                    &mut object_227,
                    item_226,
                )?;
                object_227.finish();
            }
        }
        array_225.finish();
    }
    if let Some(var_228) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_228).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_gateway_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcGatewayRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_229) = &input.target {
        #[allow(unused_mut)]
        let mut object_230 = object.key("target").start_object();
        crate::json_ser::serialize_structure_crate_model_gateway_route_target(
            &mut object_230,
            var_229,
        )?;
        object_230.finish();
    }
    if let Some(var_231) = &input.rewrite {
        #[allow(unused_mut)]
        let mut object_232 = object.key("rewrite").start_object();
        crate::json_ser::serialize_structure_crate_model_grpc_gateway_route_rewrite(
            &mut object_232,
            var_231,
        )?;
        object_232.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_233) = &input.prefix {
        object.key("prefix").string(var_233.as_str());
    }
    if let Some(var_234) = &input.path {
        #[allow(unused_mut)]
        let mut object_235 = object.key("path").start_object();
        crate::json_ser::serialize_structure_crate_model_http_path_match(&mut object_235, var_234)?;
        object_235.finish();
    }
    if let Some(var_236) = &input.query_parameters {
        let mut array_237 = object.key("queryParameters").start_array();
        for item_238 in var_236 {
            {
                #[allow(unused_mut)]
                let mut object_239 = array_237.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_query_parameter(
                    &mut object_239,
                    item_238,
                )?;
                object_239.finish();
            }
        }
        array_237.finish();
    }
    if let Some(var_240) = &input.method {
        object.key("method").string(var_240.as_str());
    }
    if let Some(var_241) = &input.scheme {
        object.key("scheme").string(var_241.as_str());
    }
    if let Some(var_242) = &input.headers {
        let mut array_243 = object.key("headers").start_array();
        for item_244 in var_242 {
            {
                #[allow(unused_mut)]
                let mut object_245 = array_243.value().start_object();
                crate::json_ser::serialize_structure_crate_model_http_route_header(
                    &mut object_245,
                    item_244,
                )?;
                object_245.finish();
            }
        }
        array_243.finish();
    }
    if let Some(var_246) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_246).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_247) = &input.weighted_targets {
        let mut array_248 = object.key("weightedTargets").start_array();
        for item_249 in var_247 {
            {
                #[allow(unused_mut)]
                let mut object_250 = array_248.value().start_object();
                crate::json_ser::serialize_structure_crate_model_weighted_target(
                    &mut object_250,
                    item_249,
                )?;
                object_250.finish();
            }
        }
        array_248.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_retry_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpRetryPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_251) = &input.per_retry_timeout {
        #[allow(unused_mut)]
        let mut object_252 = object.key("perRetryTimeout").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_252, var_251)?;
        object_252.finish();
    }
    if let Some(var_253) = &input.max_retries {
        object.key("maxRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_253).into()),
        );
    }
    if let Some(var_254) = &input.http_retry_events {
        let mut array_255 = object.key("httpRetryEvents").start_array();
        for item_256 in var_254 {
            {
                array_255.value().string(item_256.as_str());
            }
        }
        array_255.finish();
    }
    if let Some(var_257) = &input.tcp_retry_events {
        let mut array_258 = object.key("tcpRetryEvents").start_array();
        for item_259 in var_257 {
            {
                array_258.value().string(item_259.as_str());
            }
        }
        array_258.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_http_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::HttpTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_260) = &input.per_request {
        #[allow(unused_mut)]
        let mut object_261 = object.key("perRequest").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_261, var_260)?;
        object_261.finish();
    }
    if let Some(var_262) = &input.idle {
        #[allow(unused_mut)]
        let mut object_263 = object.key("idle").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_263, var_262)?;
        object_263.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_264) = &input.weighted_targets {
        let mut array_265 = object.key("weightedTargets").start_array();
        for item_266 in var_264 {
            {
                #[allow(unused_mut)]
                let mut object_267 = array_265.value().start_object();
                crate::json_ser::serialize_structure_crate_model_weighted_target(
                    &mut object_267,
                    item_266,
                )?;
                object_267.finish();
            }
        }
        array_265.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_268) = &input.idle {
        #[allow(unused_mut)]
        let mut object_269 = object.key("idle").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_269, var_268)?;
        object_269.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_tcp_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::TcpRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_270) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_270).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route_action(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRouteAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_271) = &input.weighted_targets {
        let mut array_272 = object.key("weightedTargets").start_array();
        for item_273 in var_271 {
            {
                #[allow(unused_mut)]
                let mut object_274 = array_272.value().start_object();
                crate::json_ser::serialize_structure_crate_model_weighted_target(
                    &mut object_274,
                    item_273,
                )?;
                object_274.finish();
            }
        }
        array_272.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_route_match(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRouteMatch,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_275) = &input.service_name {
        object.key("serviceName").string(var_275.as_str());
    }
    if let Some(var_276) = &input.method_name {
        object.key("methodName").string(var_276.as_str());
    }
    if let Some(var_277) = &input.metadata {
        let mut array_278 = object.key("metadata").start_array();
        for item_279 in var_277 {
            {
                #[allow(unused_mut)]
                let mut object_280 = array_278.value().start_object();
                crate::json_ser::serialize_structure_crate_model_grpc_route_metadata(
                    &mut object_280,
                    item_279,
                )?;
                object_280.finish();
            }
        }
        array_278.finish();
    }
    if let Some(var_281) = &input.port {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_281).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_retry_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcRetryPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_282) = &input.per_retry_timeout {
        #[allow(unused_mut)]
        let mut object_283 = object.key("perRetryTimeout").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_283, var_282)?;
        object_283.finish();
    }
    if let Some(var_284) = &input.max_retries {
        object.key("maxRetries").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_284).into()),
        );
    }
    if let Some(var_285) = &input.http_retry_events {
        let mut array_286 = object.key("httpRetryEvents").start_array();
        for item_287 in var_285 {
            {
                array_286.value().string(item_287.as_str());
            }
        }
        array_286.finish();
    }
    if let Some(var_288) = &input.tcp_retry_events {
        let mut array_289 = object.key("tcpRetryEvents").start_array();
        for item_290 in var_288 {
            {
                array_289.value().string(item_290.as_str());
            }
        }
        array_289.finish();
    }
    if let Some(var_291) = &input.grpc_retry_events {
        let mut array_292 = object.key("grpcRetryEvents").start_array();
        for item_293 in var_291 {
            {
                array_292.value().string(item_293.as_str());
            }
        }
        array_292.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_grpc_timeout(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::GrpcTimeout,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_294) = &input.per_request {
        #[allow(unused_mut)]
        let mut object_295 = object.key("perRequest").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_295, var_294)?;
        object_295.finish();
    }
    if let Some(var_296) = &input.idle {
        #[allow(unused_mut)]
        let mut object_297 = object.key("idle").start_object();
        crate::json_ser::serialize_structure_crate_model_duration(&mut object_297, var_296)?;
        object_297.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_client_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayClientPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_298) = &input.tls {
        #[allow(unused_mut)]
        let mut object_299 = object.key("tls").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_client_policy_tls(
            &mut object_299,
            var_298,
        )?;
        object_299.finish();
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_health_check_policy(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayHealthCheckPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_300) = &input.timeout_millis {
        object.key("timeoutMillis").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_300).into()),
        );
    }
    if let Some(var_301) = &input.interval_millis {
        object.key("intervalMillis").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((*var_301).into()),
        );
    }
    if let Some(var_302) = &input.protocol {
        object.key("protocol").string(var_302.as_str());
    }
    if input.port != 0 {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_303) = &input.path {
        object.key("path").string(var_303.as_str());
    }
    {
        object.key("healthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.healthy_threshold).into()),
        );
    }
    {
        object.key("unhealthyThreshold").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.unhealthy_threshold).into()),
        );
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_port_mapping(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayPortMapping,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    {
        object.key("port").number(
            #[allow(clippy::useless_conversion)]
            aws_smithy_types::Number::NegInt((input.port).into()),
        );
    }
    if let Some(var_304) = &input.protocol {
        object.key("protocol").string(var_304.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_virtual_gateway_listener_tls(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayListenerTls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_305) = &input.mode {
        object.key("mode").string(var_305.as_str());
    }
    if let Some(var_306) = &input.validation {
        #[allow(unused_mut)]
        let mut object_307 = object.key("validation").start_object();
        crate::json_ser::serialize_structure_crate_model_virtual_gateway_listener_tls_validation_context(&mut object_307, var_306)?;
        object_307.finish();
    }
    if let Some(var_308) = &input.certificate {
        #[allow(unused_mut)]
        let mut object_309 = object.key("certificate").start_object();
        crate::json_ser::serialize_union_crate_model_virtual_gateway_listener_tls_certificate(
            &mut object_309,
            var_308,
        )?;
        object_309.finish();
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_connection_pool(
    object_176: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayConnectionPool,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayConnectionPool::Http(inner) => {
            #[allow(unused_mut)]
            let mut object_310 = object_176.key("http").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_http_connection_pool(
                &mut object_310,
                inner,
            )?;
            object_310.finish();
        }
        crate::model::VirtualGatewayConnectionPool::Http2(inner) => {
            #[allow(unused_mut)]
            let mut object_311 = object_176.key("http2").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_http2_connection_pool(
                &mut object_311,
                inner,
            )?;
            object_311.finish();
        }
        crate::model::VirtualGatewayConnectionPool::Grpc(inner) => {
            #[allow(unused_mut)]
            let mut object_312 = object_176.key("grpc").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_grpc_connection_pool(
                &mut object_312,
                inner,
            )?;
            object_312.finish();
        }
        crate::model::VirtualGatewayConnectionPool::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayConnectionPool",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_union_crate_model_virtual_gateway_access_log(
    object_178: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::VirtualGatewayAccessLog,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    match input {
        crate::model::VirtualGatewayAccessLog::File(inner) => {
            #[allow(unused_mut)]
            let mut object_313 = object_178.key("file").start_object();
            crate::json_ser::serialize_structure_crate_model_virtual_gateway_file_access_log(
                &mut object_313,
                inner,
            )?;
            object_313.finish();
        }
        crate::model::VirtualGatewayAccessLog::Unknown => {
            return Err(
                aws_smithy_http::operation::error::SerializationError::unknown_variant(
                    "VirtualGatewayAccessLog",
                ),
            )
        }
    }
    Ok(())
}

pub fn serialize_structure_crate_model_dns_service_discovery(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::DnsServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_314) = &input.hostname {
        object.key("hostname").string(var_314.as_str());
    }
    if let Some(var_315) = &input.response_type {
        object.key("responseType").string(var_315.as_str());
    }
    if let Some(var_316) = &input.ip_preference {
        object.key("ipPreference").string(var_316.as_str());
    }
    Ok(())
}

pub fn serialize_structure_crate_model_aws_cloud_map_service_discovery(
    object: &mut aws_smithy_json::serialize::JsonObjectWriter,
    input: &crate::model::AwsCloudMapServiceDiscovery,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
    if let Some(var_317) = &input.namespace_name {
        object.key("namespaceName").string(var_317.as_str());
    }
    if let Some(var_318) = &input.service_name {
        object.key("serviceName").string(var_318.as_str());
    }
    if let Some(var_319) = &input.attributes {
        let mut array_320 = object.key("attributes").start_array();
        for item_321 in var_319 {
            {
                #[allow(unused_mut)]
                let mut object_322 = array_320.value().start_object();
                crate::json_ser::serialize_structure_crate_model_aws_cloud_map_instance_attribute(
                    &mut object_322,
                    item_321,
                )?;
                object_322.finish();
            }
        }
        array_320.finish();
    }
    if let Some(var_323) = &input.ip_preference {
        object.key("ipPreference").string(var_323.as_str());
    }
    Ok(())
}

pub const fn values() -> &'static [&'static str]

Returns all the &str values of the enum members.

Trait Implementations

impl AsRef<str> for IpPreference

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for IpPreference

fn clone(&self) -> IpPreference

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IpPreference

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

Formats the value using the given formatter.

impl From<&str> for IpPreference

fn from(s: &str) -> Self

Converts to this type from the input type.

impl FromStr for IpPreference

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for IpPreference

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for IpPreference

fn cmp(&self, other: &IpPreference) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<IpPreference> for IpPreference

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

fn partial_cmp(&self, other: &IpPreference) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for IpPreference

impl StructuralEq for IpPreference

impl StructuralPartialEq for IpPreference