10038 10038 | .use_s3_express_control_endpoint(false)
|
10039 10039 | .disable_s3_express_session_auth(true)
|
10040 10040 | .build()
|
10041 10041 | .expect("invalid params");
|
10042 10042 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10043 10043 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10044 10044 | let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad AP format error no session auth]");
|
10045 10045 | assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
|
10046 10046 | }
|
10047 10047 |
|
10048 - | /// dual-stack error
|
10048 + | /// accelerate error
|
10049 10049 | #[test]
|
10050 10050 | fn test_338() {
|
10051 10051 | let params = crate::config::endpoint::Params::builder()
|
10052 10052 | .region("us-east-1".to_string())
|
10053 10053 | .bucket("mybucket--test-ab1--x-s3".to_string())
|
10054 10054 | .use_fips(false)
|
10055 - | .use_dual_stack(true)
|
10056 - | .accelerate(false)
|
10055 + | .use_dual_stack(false)
|
10056 + | .accelerate(true)
|
10057 10057 | .use_s3_express_control_endpoint(false)
|
10058 10058 | .build()
|
10059 10059 | .expect("invalid params");
|
10060 10060 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10061 10061 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10062 - | let error = endpoint.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error]");
|
10063 - | assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
|
10062 + | let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
|
10063 + | assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
|
10064 10064 | }
|
10065 10065 |
|
10066 - | /// dual-stack error with AP
|
10066 + | /// accelerate error with AP
|
10067 10067 | #[test]
|
10068 10068 | fn test_339() {
|
10069 10069 | let params = crate::config::endpoint::Params::builder()
|
10070 10070 | .region("us-east-1".to_string())
|
10071 10071 | .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
|
10072 10072 | .use_fips(false)
|
10073 - | .use_dual_stack(true)
|
10074 - | .accelerate(false)
|
10073 + | .use_dual_stack(false)
|
10074 + | .accelerate(true)
|
10075 10075 | .use_s3_express_control_endpoint(false)
|
10076 10076 | .build()
|
10077 10077 | .expect("invalid params");
|
10078 10078 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10079 10079 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10080 - | let error = endpoint.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error with AP]");
|
10081 - | assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
|
10080 + | let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
|
10081 + | assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
|
10082 10082 | }
|
10083 10083 |
|
10084 - | /// accelerate error
|
10084 + | /// Data plane bucket format error
|
10085 10085 | #[test]
|
10086 10086 | fn test_340() {
|
10087 10087 | let params = crate::config::endpoint::Params::builder()
|
10088 10088 | .region("us-east-1".to_string())
|
10089 - | .bucket("mybucket--test-ab1--x-s3".to_string())
|
10089 + | .bucket("my.bucket--test-ab1--x-s3".to_string())
|
10090 10090 | .use_fips(false)
|
10091 10091 | .use_dual_stack(false)
|
10092 - | .accelerate(true)
|
10092 + | .accelerate(false)
|
10093 10093 | .use_s3_express_control_endpoint(false)
|
10094 10094 | .build()
|
10095 10095 | .expect("invalid params");
|
10096 10096 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10097 10097 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10098 - | let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
|
10099 - | assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
|
10098 + | let error =
|
10099 + | endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
|
10100 + | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10100 10101 | }
|
10101 10102 |
|
10102 - | /// accelerate error with AP
|
10103 + | /// Data plane AP format error
|
10103 10104 | #[test]
|
10104 10105 | fn test_341() {
|
10105 10106 | let params = crate::config::endpoint::Params::builder()
|
10106 10107 | .region("us-east-1".to_string())
|
10107 - | .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
|
10108 + | .bucket("my.myaccesspoint--test-ab1--xa-s3".to_string())
|
10108 10109 | .use_fips(false)
|
10109 10110 | .use_dual_stack(false)
|
10110 - | .accelerate(true)
|
10111 + | .accelerate(false)
|
10111 10112 | .use_s3_express_control_endpoint(false)
|
10112 10113 | .build()
|
10113 10114 | .expect("invalid params");
|
10114 10115 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10115 10116 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10116 - | let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
|
10117 - | assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
|
10117 + | let error = endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
|
10118 + | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10118 10119 | }
|
10119 10120 |
|
10120 - | /// Data plane bucket format error
|
10121 + | /// host override data plane bucket error session auth
|
10121 10122 | #[test]
|
10122 10123 | fn test_342() {
|
10123 10124 | let params = crate::config::endpoint::Params::builder()
|
10124 - | .region("us-east-1".to_string())
|
10125 - | .bucket("my.bucket--test-ab1--x-s3".to_string())
|
10125 + | .region("us-west-2".to_string())
|
10126 + | .bucket("my.bucket--usw2-az1--x-s3".to_string())
|
10126 10127 | .use_fips(false)
|
10127 10128 | .use_dual_stack(false)
|
10128 10129 | .accelerate(false)
|
10129 - | .use_s3_express_control_endpoint(false)
|
10130 + | .endpoint("https://custom.com".to_string())
|
10130 10131 | .build()
|
10131 10132 | .expect("invalid params");
|
10132 10133 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10133 10134 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10134 - | let error =
|
10135 - | endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
|
10135 + | let error = endpoint.expect_err(
|
10136 + | "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
|
10137 + | );
|
10136 10138 | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10137 10139 | }
|
10138 10140 |
|
10139 - | /// Data plane AP format error
|
10141 + | /// host override data plane AP error session auth
|
10140 10142 | #[test]
|
10141 10143 | fn test_343() {
|
10142 10144 | let params = crate::config::endpoint::Params::builder()
|
10143 - | .region("us-east-1".to_string())
|
10144 - | .bucket("my.myaccesspoint--test-ab1--xa-s3".to_string())
|
10145 + | .region("us-west-2".to_string())
|
10146 + | .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
|
10145 10147 | .use_fips(false)
|
10146 10148 | .use_dual_stack(false)
|
10147 10149 | .accelerate(false)
|
10148 - | .use_s3_express_control_endpoint(false)
|
10150 + | .endpoint("https://custom.com".to_string())
|
10149 10151 | .build()
|
10150 10152 | .expect("invalid params");
|
10151 10153 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10152 10154 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10153 - | let error = endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
|
10155 + | let error = endpoint.expect_err(
|
10156 + | "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]",
|
10157 + | );
|
10158 + | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10159 + | }
|
10160 + |
|
10161 + | /// host override data plane bucket error
|
10162 + | #[test]
|
10163 + | fn test_344() {
|
10164 + | let params = crate::config::endpoint::Params::builder()
|
10165 + | .region("us-west-2".to_string())
|
10166 + | .bucket("my.bucket--usw2-az1--x-s3".to_string())
|
10167 + | .use_fips(false)
|
10168 + | .use_dual_stack(false)
|
10169 + | .accelerate(false)
|
10170 + | .endpoint("https://custom.com".to_string())
|
10171 + | .disable_s3_express_session_auth(true)
|
10172 + | .build()
|
10173 + | .expect("invalid params");
|
10174 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10175 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10176 + | let error = endpoint
|
10177 + | .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
|
10178 + | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10179 + | }
|
10180 + |
|
10181 + | /// host override data plane AP error
|
10182 + | #[test]
|
10183 + | fn test_345() {
|
10184 + | let params = crate::config::endpoint::Params::builder()
|
10185 + | .region("us-west-2".to_string())
|
10186 + | .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
|
10187 + | .use_fips(false)
|
10188 + | .use_dual_stack(false)
|
10189 + | .accelerate(false)
|
10190 + | .endpoint("https://custom.com".to_string())
|
10191 + | .disable_s3_express_session_auth(true)
|
10192 + | .build()
|
10193 + | .expect("invalid params");
|
10194 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10195 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10196 + | let error =
|
10197 + | endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error]");
|
10154 10198 | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10155 10199 | }
|
10156 10200 |
|
10157 - | /// host override data plane bucket error session auth
|
10201 + | /// Control plane without bucket and dualstack
|
10202 + | #[test]
|
10203 + | fn test_346() {
|
10204 + | let params = crate::config::endpoint::Params::builder()
|
10205 + | .region("us-east-1".to_string())
|
10206 + | .use_fips(false)
|
10207 + | .use_dual_stack(true)
|
10208 + | .accelerate(false)
|
10209 + | .use_s3_express_control_endpoint(true)
|
10210 + | .disable_s3_express_session_auth(false)
|
10211 + | .build()
|
10212 + | .expect("invalid params");
|
10213 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10214 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10215 + | let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com");
|
10216 + | assert_eq!(
|
10217 + | endpoint,
|
10218 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10219 + | .url("https://s3express-control.dualstack.us-east-1.amazonaws.com")
|
10220 + | .property(
|
10221 + | "authSchemes",
|
10222 + | vec![{
|
10223 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10224 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10225 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10226 + | out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
|
10227 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10228 + | out
|
10229 + | }
|
10230 + | .into()]
|
10231 + | )
|
10232 + | .property("backend", "S3Express".to_string())
|
10233 + | .build()
|
10234 + | );
|
10235 + | }
|
10236 + |
|
10237 + | /// Control plane without bucket, fips and dualstack
|
10238 + | #[test]
|
10239 + | fn test_347() {
|
10240 + | let params = crate::config::endpoint::Params::builder()
|
10241 + | .region("us-east-1".to_string())
|
10242 + | .use_fips(true)
|
10243 + | .use_dual_stack(true)
|
10244 + | .accelerate(false)
|
10245 + | .use_s3_express_control_endpoint(true)
|
10246 + | .disable_s3_express_session_auth(false)
|
10247 + | .build()
|
10248 + | .expect("invalid params");
|
10249 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10250 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10251 + | let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com");
|
10252 + | assert_eq!(
|
10253 + | endpoint,
|
10254 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10255 + | .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com")
|
10256 + | .property(
|
10257 + | "authSchemes",
|
10258 + | vec![{
|
10259 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10260 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10261 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10262 + | out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
|
10263 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10264 + | out
|
10265 + | }
|
10266 + | .into()]
|
10267 + | )
|
10268 + | .property("backend", "S3Express".to_string())
|
10269 + | .build()
|
10270 + | );
|
10271 + | }
|
10272 + |
|
10273 + | /// Data Plane with short AZ and dualstack
|
10274 + | #[test]
|
10275 + | fn test_348() {
|
10276 + | let params = crate::config::endpoint::Params::builder()
|
10277 + | .region("us-west-2".to_string())
|
10278 + | .bucket("mybucket--usw2-az1--x-s3".to_string())
|
10279 + | .use_fips(false)
|
10280 + | .use_dual_stack(true)
|
10281 + | .accelerate(false)
|
10282 + | .use_s3_express_control_endpoint(false)
|
10283 + | .build()
|
10284 + | .expect("invalid params");
|
10285 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10286 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10287 + | let endpoint =
|
10288 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
10289 + | assert_eq!(
|
10290 + | endpoint,
|
10291 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10292 + | .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
10293 + | .property(
|
10294 + | "authSchemes",
|
10295 + | vec![{
|
10296 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10297 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10298 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10299 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10300 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10301 + | out
|
10302 + | }
|
10303 + | .into()]
|
10304 + | )
|
10305 + | .property("backend", "S3Express".to_string())
|
10306 + | .build()
|
10307 + | );
|
10308 + | }
|
10309 + |
|
10310 + | /// Data Plane with short AZ and FIPS with dualstack
|
10311 + | #[test]
|
10312 + | fn test_349() {
|
10313 + | let params = crate::config::endpoint::Params::builder()
|
10314 + | .region("us-west-2".to_string())
|
10315 + | .bucket("mybucket--usw2-az1--x-s3".to_string())
|
10316 + | .use_fips(true)
|
10317 + | .use_dual_stack(true)
|
10318 + | .accelerate(false)
|
10319 + | .use_s3_express_control_endpoint(false)
|
10320 + | .build()
|
10321 + | .expect("invalid params");
|
10322 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10323 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10324 + | let endpoint =
|
10325 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
10326 + | assert_eq!(
|
10327 + | endpoint,
|
10328 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10329 + | .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
10330 + | .property(
|
10331 + | "authSchemes",
|
10332 + | vec![{
|
10333 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10334 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10335 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10336 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10337 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10338 + | out
|
10339 + | }
|
10340 + | .into()]
|
10341 + | )
|
10342 + | .property("backend", "S3Express".to_string())
|
10343 + | .build()
|
10344 + | );
|
10345 + | }
|
10346 + |
|
10347 + | /// Data Plane sigv4 auth with short AZ and dualstack
|
10348 + | #[test]
|
10349 + | fn test_350() {
|
10350 + | let params = crate::config::endpoint::Params::builder()
|
10351 + | .region("us-west-2".to_string())
|
10352 + | .bucket("mybucket--usw2-az1--x-s3".to_string())
|
10353 + | .use_fips(false)
|
10354 + | .use_dual_stack(true)
|
10355 + | .accelerate(false)
|
10356 + | .disable_s3_express_session_auth(true)
|
10357 + | .build()
|
10358 + | .expect("invalid params");
|
10359 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10360 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10361 + | let endpoint =
|
10362 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
10363 + | assert_eq!(
|
10364 + | endpoint,
|
10365 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10366 + | .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
10367 + | .property(
|
10368 + | "authSchemes",
|
10369 + | vec![{
|
10370 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10371 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10372 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10373 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10374 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10375 + | out
|
10376 + | }
|
10377 + | .into()]
|
10378 + | )
|
10379 + | .property("backend", "S3Express".to_string())
|
10380 + | .build()
|
10381 + | );
|
10382 + | }
|
10383 + |
|
10384 + | /// Data Plane sigv4 auth with short AZ and FIPS with dualstack
|
10385 + | #[test]
|
10386 + | fn test_351() {
|
10387 + | let params = crate::config::endpoint::Params::builder()
|
10388 + | .region("us-west-2".to_string())
|
10389 + | .bucket("mybucket--usw2-az1--x-s3".to_string())
|
10390 + | .use_fips(true)
|
10391 + | .use_dual_stack(true)
|
10392 + | .accelerate(false)
|
10393 + | .disable_s3_express_session_auth(true)
|
10394 + | .build()
|
10395 + | .expect("invalid params");
|
10396 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10397 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10398 + | let endpoint =
|
10399 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
10400 + | assert_eq!(
|
10401 + | endpoint,
|
10402 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10403 + | .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
10404 + | .property(
|
10405 + | "authSchemes",
|
10406 + | vec![{
|
10407 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10408 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10409 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10410 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10411 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10412 + | out
|
10413 + | }
|
10414 + | .into()]
|
10415 + | )
|
10416 + | .property("backend", "S3Express".to_string())
|
10417 + | .build()
|
10418 + | );
|
10419 + | }
|
10420 + |
|
10421 + | /// Data Plane with zone and dualstack
|
10422 + | #[test]
|
10423 + | fn test_352() {
|
10424 + | let params = crate::config::endpoint::Params::builder()
|
10425 + | .region("us-west-2".to_string())
|
10426 + | .bucket("mybucket--usw2-az12--x-s3".to_string())
|
10427 + | .use_fips(false)
|
10428 + | .use_dual_stack(true)
|
10429 + | .accelerate(false)
|
10430 + | .use_s3_express_control_endpoint(false)
|
10431 + | .build()
|
10432 + | .expect("invalid params");
|
10433 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10434 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10435 + | let endpoint =
|
10436 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
10437 + | assert_eq!(
|
10438 + | endpoint,
|
10439 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10440 + | .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
10441 + | .property(
|
10442 + | "authSchemes",
|
10443 + | vec![{
|
10444 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10445 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10446 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10447 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10448 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10449 + | out
|
10450 + | }
|
10451 + | .into()]
|
10452 + | )
|
10453 + | .property("backend", "S3Express".to_string())
|
10454 + | .build()
|
10455 + | );
|
10456 + | }
|
10457 + |
|
10458 + | /// Data Plane with zone and FIPS with dualstack
|
10459 + | #[test]
|
10460 + | fn test_353() {
|
10461 + | let params = crate::config::endpoint::Params::builder()
|
10462 + | .region("us-west-2".to_string())
|
10463 + | .bucket("mybucket--usw2-az12--x-s3".to_string())
|
10464 + | .use_fips(true)
|
10465 + | .use_dual_stack(true)
|
10466 + | .accelerate(false)
|
10467 + | .use_s3_express_control_endpoint(false)
|
10468 + | .build()
|
10469 + | .expect("invalid params");
|
10470 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10471 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10472 + | let endpoint =
|
10473 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
10474 + | assert_eq!(
|
10475 + | endpoint,
|
10476 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10477 + | .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
10478 + | .property(
|
10479 + | "authSchemes",
|
10480 + | vec![{
|
10481 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10482 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10483 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10484 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10485 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10486 + | out
|
10487 + | }
|
10488 + | .into()]
|
10489 + | )
|
10490 + | .property("backend", "S3Express".to_string())
|
10491 + | .build()
|
10492 + | );
|
10493 + | }
|
10494 + |
|
10495 + | /// Data Plane sigv4 auth with zone and dualstack
|
10496 + | #[test]
|
10497 + | fn test_354() {
|
10498 + | let params = crate::config::endpoint::Params::builder()
|
10499 + | .region("us-west-2".to_string())
|
10500 + | .bucket("mybucket--usw2-az12--x-s3".to_string())
|
10501 + | .use_fips(false)
|
10502 + | .use_dual_stack(true)
|
10503 + | .accelerate(false)
|
10504 + | .disable_s3_express_session_auth(true)
|
10505 + | .build()
|
10506 + | .expect("invalid params");
|
10507 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10508 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10509 + | let endpoint =
|
10510 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
10511 + | assert_eq!(
|
10512 + | endpoint,
|
10513 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10514 + | .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
10515 + | .property(
|
10516 + | "authSchemes",
|
10517 + | vec![{
|
10518 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10519 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10520 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10521 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10522 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10523 + | out
|
10524 + | }
|
10525 + | .into()]
|
10526 + | )
|
10527 + | .property("backend", "S3Express".to_string())
|
10528 + | .build()
|
10529 + | );
|
10530 + | }
|
10531 + |
|
10532 + | /// Data Plane sigv4 auth with 9-char zone and FIPS with dualstack
|
10533 + | #[test]
|
10534 + | fn test_355() {
|
10535 + | let params = crate::config::endpoint::Params::builder()
|
10536 + | .region("us-west-2".to_string())
|
10537 + | .bucket("mybucket--usw2-az12--x-s3".to_string())
|
10538 + | .use_fips(true)
|
10539 + | .use_dual_stack(true)
|
10540 + | .accelerate(false)
|
10541 + | .disable_s3_express_session_auth(true)
|
10542 + | .build()
|
10543 + | .expect("invalid params");
|
10544 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10545 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10546 + | let endpoint =
|
10547 + | endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
10548 + | assert_eq!(
|
10549 + | endpoint,
|
10550 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10551 + | .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
10552 + | .property(
|
10553 + | "authSchemes",
|
10554 + | vec![{
|
10555 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10556 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10557 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10558 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10559 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10560 + | out
|
10561 + | }
|
10562 + | .into()]
|
10563 + | )
|
10564 + | .property("backend", "S3Express".to_string())
|
10565 + | .build()
|
10566 + | );
|
10567 + | }
|
10568 + |
|
10569 + | /// Data Plane with 13-char zone and dualstack
|
10570 + | #[test]
|
10571 + | fn test_356() {
|
10572 + | let params = crate::config::endpoint::Params::builder()
|
10573 + | .region("us-west-2".to_string())
|
10574 + | .bucket("mybucket--test-zone-ab1--x-s3".to_string())
|
10575 + | .use_fips(false)
|
10576 + | .use_dual_stack(true)
|
10577 + | .accelerate(false)
|
10578 + | .use_s3_express_control_endpoint(false)
|
10579 + | .build()
|
10580 + | .expect("invalid params");
|
10581 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10582 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10583 + | let endpoint = endpoint
|
10584 + | .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10585 + | assert_eq!(
|
10586 + | endpoint,
|
10587 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10588 + | .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10589 + | .property(
|
10590 + | "authSchemes",
|
10591 + | vec![{
|
10592 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10593 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10594 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10595 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10596 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10597 + | out
|
10598 + | }
|
10599 + | .into()]
|
10600 + | )
|
10601 + | .property("backend", "S3Express".to_string())
|
10602 + | .build()
|
10603 + | );
|
10604 + | }
|
10605 + |
|
10606 + | /// Data Plane with 13-char zone and FIPS with dualstack
|
10607 + | #[test]
|
10608 + | fn test_357() {
|
10609 + | let params = crate::config::endpoint::Params::builder()
|
10610 + | .region("us-west-2".to_string())
|
10611 + | .bucket("mybucket--test-zone-ab1--x-s3".to_string())
|
10612 + | .use_fips(true)
|
10613 + | .use_dual_stack(true)
|
10614 + | .accelerate(false)
|
10615 + | .use_s3_express_control_endpoint(false)
|
10616 + | .build()
|
10617 + | .expect("invalid params");
|
10618 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10619 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10620 + | let endpoint = endpoint
|
10621 + | .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10622 + | assert_eq!(
|
10623 + | endpoint,
|
10624 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10625 + | .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10626 + | .property(
|
10627 + | "authSchemes",
|
10628 + | vec![{
|
10629 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10630 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10631 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10632 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10633 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10634 + | out
|
10635 + | }
|
10636 + | .into()]
|
10637 + | )
|
10638 + | .property("backend", "S3Express".to_string())
|
10639 + | .build()
|
10640 + | );
|
10641 + | }
|
10642 + |
|
10643 + | /// Data Plane sigv4 auth with 13-char zone and dualstack
|
10644 + | #[test]
|
10645 + | fn test_358() {
|
10646 + | let params = crate::config::endpoint::Params::builder()
|
10647 + | .region("us-west-2".to_string())
|
10648 + | .bucket("mybucket--test-zone-ab1--x-s3".to_string())
|
10649 + | .use_fips(false)
|
10650 + | .use_dual_stack(true)
|
10651 + | .accelerate(false)
|
10652 + | .disable_s3_express_session_auth(true)
|
10653 + | .build()
|
10654 + | .expect("invalid params");
|
10655 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10656 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10657 + | let endpoint = endpoint
|
10658 + | .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10659 + | assert_eq!(
|
10660 + | endpoint,
|
10661 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10662 + | .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10663 + | .property(
|
10664 + | "authSchemes",
|
10665 + | vec![{
|
10666 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10667 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10668 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10669 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10670 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10671 + | out
|
10672 + | }
|
10673 + | .into()]
|
10674 + | )
|
10675 + | .property("backend", "S3Express".to_string())
|
10676 + | .build()
|
10677 + | );
|
10678 + | }
|
10679 + |
|
10680 + | /// Data Plane sigv4 auth with 13-char zone and FIPS with dualstack
|
10681 + | #[test]
|
10682 + | fn test_359() {
|
10683 + | let params = crate::config::endpoint::Params::builder()
|
10684 + | .region("us-west-2".to_string())
|
10685 + | .bucket("mybucket--test-zone-ab1--x-s3".to_string())
|
10686 + | .use_fips(true)
|
10687 + | .use_dual_stack(true)
|
10688 + | .accelerate(false)
|
10689 + | .disable_s3_express_session_auth(true)
|
10690 + | .build()
|
10691 + | .expect("invalid params");
|
10692 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10693 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10694 + | let endpoint = endpoint
|
10695 + | .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10696 + | assert_eq!(
|
10697 + | endpoint,
|
10698 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10699 + | .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10700 + | .property(
|
10701 + | "authSchemes",
|
10702 + | vec![{
|
10703 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10704 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10705 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10706 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10707 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10708 + | out
|
10709 + | }
|
10710 + | .into()]
|
10711 + | )
|
10712 + | .property("backend", "S3Express".to_string())
|
10713 + | .build()
|
10714 + | );
|
10715 + | }
|
10716 + |
|
10717 + | /// Data Plane with 14-char zone and dualstack
|
10718 + | #[test]
|
10719 + | fn test_360() {
|
10720 + | let params = crate::config::endpoint::Params::builder()
|
10721 + | .region("us-west-2".to_string())
|
10722 + | .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
|
10723 + | .use_fips(false)
|
10724 + | .use_dual_stack(true)
|
10725 + | .accelerate(false)
|
10726 + | .use_s3_express_control_endpoint(false)
|
10727 + | .build()
|
10728 + | .expect("invalid params");
|
10729 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10730 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10731 + | let endpoint = endpoint
|
10732 + | .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10733 + | assert_eq!(
|
10734 + | endpoint,
|
10735 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10736 + | .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10737 + | .property(
|
10738 + | "authSchemes",
|
10739 + | vec![{
|
10740 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10741 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10742 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10743 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10744 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10745 + | out
|
10746 + | }
|
10747 + | .into()]
|
10748 + | )
|
10749 + | .property("backend", "S3Express".to_string())
|
10750 + | .build()
|
10751 + | );
|
10752 + | }
|
10753 + |
|
10754 + | /// Data Plane with 14-char zone and FIPS with dualstack
|
10755 + | #[test]
|
10756 + | fn test_361() {
|
10757 + | let params = crate::config::endpoint::Params::builder()
|
10758 + | .region("us-west-2".to_string())
|
10759 + | .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
|
10760 + | .use_fips(true)
|
10761 + | .use_dual_stack(true)
|
10762 + | .accelerate(false)
|
10763 + | .use_s3_express_control_endpoint(false)
|
10764 + | .build()
|
10765 + | .expect("invalid params");
|
10766 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10767 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10768 + | let endpoint = endpoint.expect(
|
10769 + | "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
10770 + | );
|
10771 + | assert_eq!(
|
10772 + | endpoint,
|
10773 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10774 + | .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10775 + | .property(
|
10776 + | "authSchemes",
|
10777 + | vec![{
|
10778 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10779 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10780 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10781 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10782 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10783 + | out
|
10784 + | }
|
10785 + | .into()]
|
10786 + | )
|
10787 + | .property("backend", "S3Express".to_string())
|
10788 + | .build()
|
10789 + | );
|
10790 + | }
|
10791 + |
|
10792 + | /// Data Plane sigv4 auth with 14-char zone and dualstack
|
10793 + | #[test]
|
10794 + | fn test_362() {
|
10795 + | let params = crate::config::endpoint::Params::builder()
|
10796 + | .region("us-west-2".to_string())
|
10797 + | .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
|
10798 + | .use_fips(false)
|
10799 + | .use_dual_stack(true)
|
10800 + | .accelerate(false)
|
10801 + | .disable_s3_express_session_auth(true)
|
10802 + | .build()
|
10803 + | .expect("invalid params");
|
10804 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10805 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10806 + | let endpoint = endpoint
|
10807 + | .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10808 + | assert_eq!(
|
10809 + | endpoint,
|
10810 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10811 + | .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10812 + | .property(
|
10813 + | "authSchemes",
|
10814 + | vec![{
|
10815 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10816 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10817 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10818 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10819 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10820 + | out
|
10821 + | }
|
10822 + | .into()]
|
10823 + | )
|
10824 + | .property("backend", "S3Express".to_string())
|
10825 + | .build()
|
10826 + | );
|
10827 + | }
|
10828 + |
|
10829 + | /// Data Plane sigv4 auth with 14-char zone and FIPS with dualstack
|
10830 + | #[test]
|
10831 + | fn test_363() {
|
10832 + | let params = crate::config::endpoint::Params::builder()
|
10833 + | .region("us-west-2".to_string())
|
10834 + | .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
|
10835 + | .use_fips(true)
|
10836 + | .use_dual_stack(true)
|
10837 + | .accelerate(false)
|
10838 + | .disable_s3_express_session_auth(true)
|
10839 + | .build()
|
10840 + | .expect("invalid params");
|
10841 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10842 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10843 + | let endpoint = endpoint.expect(
|
10844 + | "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
10845 + | );
|
10846 + | assert_eq!(
|
10847 + | endpoint,
|
10848 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10849 + | .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10850 + | .property(
|
10851 + | "authSchemes",
|
10852 + | vec![{
|
10853 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10854 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10855 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10856 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10857 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10858 + | out
|
10859 + | }
|
10860 + | .into()]
|
10861 + | )
|
10862 + | .property("backend", "S3Express".to_string())
|
10863 + | .build()
|
10864 + | );
|
10865 + | }
|
10866 + |
|
10867 + | /// Data Plane with long zone (20 cha) and dualstack
|
10868 + | #[test]
|
10869 + | fn test_364() {
|
10870 + | let params = crate::config::endpoint::Params::builder()
|
10871 + | .region("us-west-2".to_string())
|
10872 + | .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
|
10873 + | .use_fips(false)
|
10874 + | .use_dual_stack(true)
|
10875 + | .accelerate(false)
|
10876 + | .use_s3_express_control_endpoint(false)
|
10877 + | .build()
|
10878 + | .expect("invalid params");
|
10879 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10880 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10881 + | let endpoint = endpoint.expect(
|
10882 + | "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
10883 + | );
|
10884 + | assert_eq!(
|
10885 + | endpoint,
|
10886 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10887 + | .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10888 + | .property(
|
10889 + | "authSchemes",
|
10890 + | vec![{
|
10891 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10892 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10893 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10894 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10895 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10896 + | out
|
10897 + | }
|
10898 + | .into()]
|
10899 + | )
|
10900 + | .property("backend", "S3Express".to_string())
|
10901 + | .build()
|
10902 + | );
|
10903 + | }
|
10904 + |
|
10905 + | /// Data Plane with long zone (20 char) and FIPS with dualstack
|
10906 + | #[test]
|
10907 + | fn test_365() {
|
10908 + | let params = crate::config::endpoint::Params::builder()
|
10909 + | .region("us-west-2".to_string())
|
10910 + | .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
|
10911 + | .use_fips(true)
|
10912 + | .use_dual_stack(true)
|
10913 + | .accelerate(false)
|
10914 + | .use_s3_express_control_endpoint(false)
|
10915 + | .build()
|
10916 + | .expect("invalid params");
|
10917 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10918 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10919 + | let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10920 + | assert_eq!(
|
10921 + | endpoint,
|
10922 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10923 + | .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10924 + | .property(
|
10925 + | "authSchemes",
|
10926 + | vec![{
|
10927 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10928 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
10929 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10930 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10931 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10932 + | out
|
10933 + | }
|
10934 + | .into()]
|
10935 + | )
|
10936 + | .property("backend", "S3Express".to_string())
|
10937 + | .build()
|
10938 + | );
|
10939 + | }
|
10940 + |
|
10941 + | /// Data Plane sigv4 auth with long zone (20 char) and dualstack
|
10942 + | #[test]
|
10943 + | fn test_366() {
|
10944 + | let params = crate::config::endpoint::Params::builder()
|
10945 + | .region("us-west-2".to_string())
|
10946 + | .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
|
10947 + | .use_fips(false)
|
10948 + | .use_dual_stack(true)
|
10949 + | .accelerate(false)
|
10950 + | .disable_s3_express_session_auth(true)
|
10951 + | .build()
|
10952 + | .expect("invalid params");
|
10953 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10954 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10955 + | let endpoint = endpoint.expect(
|
10956 + | "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
10957 + | );
|
10958 + | assert_eq!(
|
10959 + | endpoint,
|
10960 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10961 + | .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10962 + | .property(
|
10963 + | "authSchemes",
|
10964 + | vec![{
|
10965 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
10966 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
10967 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
10968 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
10969 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
10970 + | out
|
10971 + | }
|
10972 + | .into()]
|
10973 + | )
|
10974 + | .property("backend", "S3Express".to_string())
|
10975 + | .build()
|
10976 + | );
|
10977 + | }
|
10978 + |
|
10979 + | /// Data Plane sigv4 auth with long zone (20 char) and FIPS with dualstack
|
10980 + | #[test]
|
10981 + | fn test_367() {
|
10982 + | let params = crate::config::endpoint::Params::builder()
|
10983 + | .region("us-west-2".to_string())
|
10984 + | .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
|
10985 + | .use_fips(true)
|
10986 + | .use_dual_stack(true)
|
10987 + | .accelerate(false)
|
10988 + | .disable_s3_express_session_auth(true)
|
10989 + | .build()
|
10990 + | .expect("invalid params");
|
10991 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10992 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
10993 + | let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
10994 + | assert_eq!(
|
10995 + | endpoint,
|
10996 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
10997 + | .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
10998 + | .property(
|
10999 + | "authSchemes",
|
11000 + | vec![{
|
11001 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11002 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11003 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11004 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11005 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11006 + | out
|
11007 + | }
|
11008 + | .into()]
|
11009 + | )
|
11010 + | .property("backend", "S3Express".to_string())
|
11011 + | .build()
|
11012 + | );
|
11013 + | }
|
11014 + |
|
11015 + | /// Control plane and FIPS with dualstack
|
11016 + | #[test]
|
11017 + | fn test_368() {
|
11018 + | let params = crate::config::endpoint::Params::builder()
|
11019 + | .region("us-east-1".to_string())
|
11020 + | .bucket("mybucket--test-ab1--x-s3".to_string())
|
11021 + | .use_fips(true)
|
11022 + | .use_dual_stack(true)
|
11023 + | .accelerate(false)
|
11024 + | .use_s3_express_control_endpoint(true)
|
11025 + | .build()
|
11026 + | .expect("invalid params");
|
11027 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11028 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11029 + | let endpoint =
|
11030 + | endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
|
11031 + | assert_eq!(
|
11032 + | endpoint,
|
11033 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11034 + | .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
|
11035 + | .property(
|
11036 + | "authSchemes",
|
11037 + | vec![{
|
11038 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11039 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11040 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11041 + | out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
|
11042 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11043 + | out
|
11044 + | }
|
11045 + | .into()]
|
11046 + | )
|
11047 + | .property("backend", "S3Express".to_string())
|
11048 + | .build()
|
11049 + | );
|
11050 + | }
|
11051 + |
|
11052 + | /// Data plane with zone and dualstack and AP
|
11053 + | #[test]
|
11054 + | fn test_369() {
|
11055 + | let params = crate::config::endpoint::Params::builder()
|
11056 + | .region("us-west-2".to_string())
|
11057 + | .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
|
11058 + | .use_fips(false)
|
11059 + | .use_dual_stack(true)
|
11060 + | .accelerate(false)
|
11061 + | .use_s3_express_control_endpoint(false)
|
11062 + | .build()
|
11063 + | .expect("invalid params");
|
11064 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11065 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11066 + | let endpoint =
|
11067 + | endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
11068 + | assert_eq!(
|
11069 + | endpoint,
|
11070 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11071 + | .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
11072 + | .property(
|
11073 + | "authSchemes",
|
11074 + | vec![{
|
11075 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11076 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11077 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11078 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11079 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11080 + | out
|
11081 + | }
|
11082 + | .into()]
|
11083 + | )
|
11084 + | .property("backend", "S3Express".to_string())
|
11085 + | .build()
|
11086 + | );
|
11087 + | }
|
11088 + |
|
11089 + | /// Data plane with zone and FIPS with dualstack and AP
|
11090 + | #[test]
|
11091 + | fn test_370() {
|
11092 + | let params = crate::config::endpoint::Params::builder()
|
11093 + | .region("us-west-2".to_string())
|
11094 + | .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
|
11095 + | .use_fips(true)
|
11096 + | .use_dual_stack(true)
|
11097 + | .accelerate(false)
|
11098 + | .use_s3_express_control_endpoint(false)
|
11099 + | .build()
|
11100 + | .expect("invalid params");
|
11101 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11102 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11103 + | let endpoint = endpoint
|
11104 + | .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
11105 + | assert_eq!(
|
11106 + | endpoint,
|
11107 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11108 + | .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
11109 + | .property(
|
11110 + | "authSchemes",
|
11111 + | vec![{
|
11112 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11113 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11114 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11115 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11116 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11117 + | out
|
11118 + | }
|
11119 + | .into()]
|
11120 + | )
|
11121 + | .property("backend", "S3Express".to_string())
|
11122 + | .build()
|
11123 + | );
|
11124 + | }
|
11125 + |
|
11126 + | /// Data Plane sigv4 auth with zone and dualstack and AP
|
11127 + | #[test]
|
11128 + | fn test_371() {
|
11129 + | let params = crate::config::endpoint::Params::builder()
|
11130 + | .region("us-west-2".to_string())
|
11131 + | .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
|
11132 + | .use_fips(false)
|
11133 + | .use_dual_stack(true)
|
11134 + | .accelerate(false)
|
11135 + | .disable_s3_express_session_auth(true)
|
11136 + | .build()
|
11137 + | .expect("invalid params");
|
11138 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11139 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11140 + | let endpoint =
|
11141 + | endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
11142 + | assert_eq!(
|
11143 + | endpoint,
|
11144 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11145 + | .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
11146 + | .property(
|
11147 + | "authSchemes",
|
11148 + | vec![{
|
11149 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11150 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11151 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11152 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11153 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11154 + | out
|
11155 + | }
|
11156 + | .into()]
|
11157 + | )
|
11158 + | .property("backend", "S3Express".to_string())
|
11159 + | .build()
|
11160 + | );
|
11161 + | }
|
11162 + |
|
11163 + | /// Data Plane AP sigv4 auth with zone and FIPS with dualstack
|
11164 + | #[test]
|
11165 + | fn test_372() {
|
11166 + | let params = crate::config::endpoint::Params::builder()
|
11167 + | .region("us-west-2".to_string())
|
11168 + | .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
|
11169 + | .use_fips(true)
|
11170 + | .use_dual_stack(true)
|
11171 + | .accelerate(false)
|
11172 + | .disable_s3_express_session_auth(true)
|
11173 + | .build()
|
11174 + | .expect("invalid params");
|
11175 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11176 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11177 + | let endpoint = endpoint
|
11178 + | .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
|
11179 + | assert_eq!(
|
11180 + | endpoint,
|
11181 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11182 + | .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
|
11183 + | .property(
|
11184 + | "authSchemes",
|
11185 + | vec![{
|
11186 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11187 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11188 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11189 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11190 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11191 + | out
|
11192 + | }
|
11193 + | .into()]
|
11194 + | )
|
11195 + | .property("backend", "S3Express".to_string())
|
11196 + | .build()
|
11197 + | );
|
11198 + | }
|
11199 + |
|
11200 + | /// Data Plane with zone (9 char) and AP with dualstack
|
11201 + | #[test]
|
11202 + | fn test_373() {
|
11203 + | let params = crate::config::endpoint::Params::builder()
|
11204 + | .region("us-west-2".to_string())
|
11205 + | .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
|
11206 + | .use_fips(false)
|
11207 + | .use_dual_stack(true)
|
11208 + | .accelerate(false)
|
11209 + | .use_s3_express_control_endpoint(false)
|
11210 + | .build()
|
11211 + | .expect("invalid params");
|
11212 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11213 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11214 + | let endpoint =
|
11215 + | endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
11216 + | assert_eq!(
|
11217 + | endpoint,
|
11218 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11219 + | .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
11220 + | .property(
|
11221 + | "authSchemes",
|
11222 + | vec![{
|
11223 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11224 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11225 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11226 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11227 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11228 + | out
|
11229 + | }
|
11230 + | .into()]
|
11231 + | )
|
11232 + | .property("backend", "S3Express".to_string())
|
11233 + | .build()
|
11234 + | );
|
11235 + | }
|
11236 + |
|
11237 + | /// Data Plane with zone (9 char) and FIPS with AP and dualstack
|
11238 + | #[test]
|
11239 + | fn test_374() {
|
11240 + | let params = crate::config::endpoint::Params::builder()
|
11241 + | .region("us-west-2".to_string())
|
11242 + | .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
|
11243 + | .use_fips(true)
|
11244 + | .use_dual_stack(true)
|
11245 + | .accelerate(false)
|
11246 + | .use_s3_express_control_endpoint(false)
|
11247 + | .build()
|
11248 + | .expect("invalid params");
|
11249 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11250 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11251 + | let endpoint = endpoint
|
11252 + | .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
11253 + | assert_eq!(
|
11254 + | endpoint,
|
11255 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11256 + | .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
11257 + | .property(
|
11258 + | "authSchemes",
|
11259 + | vec![{
|
11260 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11261 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11262 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11263 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11264 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11265 + | out
|
11266 + | }
|
11267 + | .into()]
|
11268 + | )
|
11269 + | .property("backend", "S3Express".to_string())
|
11270 + | .build()
|
11271 + | );
|
11272 + | }
|
11273 + |
|
11274 + | /// Data Plane sigv4 auth with (9 char) zone and dualstack with AP
|
11275 + | #[test]
|
11276 + | fn test_375() {
|
11277 + | let params = crate::config::endpoint::Params::builder()
|
11278 + | .region("us-west-2".to_string())
|
11279 + | .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
|
11280 + | .use_fips(false)
|
11281 + | .use_dual_stack(true)
|
11282 + | .accelerate(false)
|
11283 + | .disable_s3_express_session_auth(true)
|
11284 + | .build()
|
11285 + | .expect("invalid params");
|
11286 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11287 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11288 + | let endpoint =
|
11289 + | endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
11290 + | assert_eq!(
|
11291 + | endpoint,
|
11292 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11293 + | .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
11294 + | .property(
|
11295 + | "authSchemes",
|
11296 + | vec![{
|
11297 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11298 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11299 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11300 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11301 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11302 + | out
|
11303 + | }
|
11304 + | .into()]
|
11305 + | )
|
11306 + | .property("backend", "S3Express".to_string())
|
11307 + | .build()
|
11308 + | );
|
11309 + | }
|
11310 + |
|
11311 + | /// Access Point sigv4 auth with (9 char) zone and FIPS with dualstack
|
11312 + | #[test]
|
11313 + | fn test_376() {
|
11314 + | let params = crate::config::endpoint::Params::builder()
|
11315 + | .region("us-west-2".to_string())
|
11316 + | .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
|
11317 + | .use_fips(true)
|
11318 + | .use_dual_stack(true)
|
11319 + | .accelerate(false)
|
11320 + | .disable_s3_express_session_auth(true)
|
11321 + | .build()
|
11322 + | .expect("invalid params");
|
11323 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11324 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11325 + | let endpoint = endpoint
|
11326 + | .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
|
11327 + | assert_eq!(
|
11328 + | endpoint,
|
11329 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11330 + | .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
|
11331 + | .property(
|
11332 + | "authSchemes",
|
11333 + | vec![{
|
11334 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11335 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11336 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11337 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11338 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11339 + | out
|
11340 + | }
|
11341 + | .into()]
|
11342 + | )
|
11343 + | .property("backend", "S3Express".to_string())
|
11344 + | .build()
|
11345 + | );
|
11346 + | }
|
11347 + |
|
11348 + | /// Data Plane with zone (13 char) and AP with dualstack
|
11349 + | #[test]
|
11350 + | fn test_377() {
|
11351 + | let params = crate::config::endpoint::Params::builder()
|
11352 + | .region("us-west-2".to_string())
|
11353 + | .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
|
11354 + | .use_fips(false)
|
11355 + | .use_dual_stack(true)
|
11356 + | .accelerate(false)
|
11357 + | .use_s3_express_control_endpoint(false)
|
11358 + | .build()
|
11359 + | .expect("invalid params");
|
11360 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11361 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11362 + | let endpoint = endpoint
|
11363 + | .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
11364 + | assert_eq!(
|
11365 + | endpoint,
|
11366 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11367 + | .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11368 + | .property(
|
11369 + | "authSchemes",
|
11370 + | vec![{
|
11371 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11372 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11373 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11374 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11375 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11376 + | out
|
11377 + | }
|
11378 + | .into()]
|
11379 + | )
|
11380 + | .property("backend", "S3Express".to_string())
|
11381 + | .build()
|
11382 + | );
|
11383 + | }
|
11384 + |
|
11385 + | /// Data Plane with zone (13 char) and AP with FIPS and dualstack
|
11386 + | #[test]
|
11387 + | fn test_378() {
|
11388 + | let params = crate::config::endpoint::Params::builder()
|
11389 + | .region("us-west-2".to_string())
|
11390 + | .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
|
11391 + | .use_fips(true)
|
11392 + | .use_dual_stack(true)
|
11393 + | .accelerate(false)
|
11394 + | .use_s3_express_control_endpoint(false)
|
11395 + | .build()
|
11396 + | .expect("invalid params");
|
11397 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11398 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11399 + | let endpoint = endpoint.expect(
|
11400 + | "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
11401 + | );
|
11402 + | assert_eq!(
|
11403 + | endpoint,
|
11404 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11405 + | .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11406 + | .property(
|
11407 + | "authSchemes",
|
11408 + | vec![{
|
11409 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11410 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11411 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11412 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11413 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11414 + | out
|
11415 + | }
|
11416 + | .into()]
|
11417 + | )
|
11418 + | .property("backend", "S3Express".to_string())
|
11419 + | .build()
|
11420 + | );
|
11421 + | }
|
11422 + |
|
11423 + | /// Data Plane sigv4 auth with (13 char) zone with AP and dualstack
|
11424 + | #[test]
|
11425 + | fn test_379() {
|
11426 + | let params = crate::config::endpoint::Params::builder()
|
11427 + | .region("us-west-2".to_string())
|
11428 + | .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
|
11429 + | .use_fips(false)
|
11430 + | .use_dual_stack(true)
|
11431 + | .accelerate(false)
|
11432 + | .disable_s3_express_session_auth(true)
|
11433 + | .build()
|
11434 + | .expect("invalid params");
|
11435 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11436 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11437 + | let endpoint = endpoint
|
11438 + | .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
11439 + | assert_eq!(
|
11440 + | endpoint,
|
11441 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11442 + | .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11443 + | .property(
|
11444 + | "authSchemes",
|
11445 + | vec![{
|
11446 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11447 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11448 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11449 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11450 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11451 + | out
|
11452 + | }
|
11453 + | .into()]
|
11454 + | )
|
11455 + | .property("backend", "S3Express".to_string())
|
11456 + | .build()
|
11457 + | );
|
11458 + | }
|
11459 + |
|
11460 + | /// Data Plane sigv4 auth with (13 char) zone with AP and FIPS and dualstack
|
11461 + | #[test]
|
11462 + | fn test_380() {
|
11463 + | let params = crate::config::endpoint::Params::builder()
|
11464 + | .region("us-west-2".to_string())
|
11465 + | .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
|
11466 + | .use_fips(true)
|
11467 + | .use_dual_stack(true)
|
11468 + | .accelerate(false)
|
11469 + | .disable_s3_express_session_auth(true)
|
11470 + | .build()
|
11471 + | .expect("invalid params");
|
11472 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11473 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11474 + | let endpoint = endpoint.expect(
|
11475 + | "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
11476 + | );
|
11477 + | assert_eq!(
|
11478 + | endpoint,
|
11479 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11480 + | .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11481 + | .property(
|
11482 + | "authSchemes",
|
11483 + | vec![{
|
11484 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11485 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11486 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11487 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11488 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11489 + | out
|
11490 + | }
|
11491 + | .into()]
|
11492 + | )
|
11493 + | .property("backend", "S3Express".to_string())
|
11494 + | .build()
|
11495 + | );
|
11496 + | }
|
11497 + |
|
11498 + | /// Data Plane with (14 char) zone and AP with dualstack
|
11499 + | #[test]
|
11500 + | fn test_381() {
|
11501 + | let params = crate::config::endpoint::Params::builder()
|
11502 + | .region("us-west-2".to_string())
|
11503 + | .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
|
11504 + | .use_fips(false)
|
11505 + | .use_dual_stack(true)
|
11506 + | .accelerate(false)
|
11507 + | .use_s3_express_control_endpoint(false)
|
11508 + | .build()
|
11509 + | .expect("invalid params");
|
11510 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11511 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11512 + | let endpoint = endpoint.expect(
|
11513 + | "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
11514 + | );
|
11515 + | assert_eq!(
|
11516 + | endpoint,
|
11517 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11518 + | .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11519 + | .property(
|
11520 + | "authSchemes",
|
11521 + | vec![{
|
11522 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11523 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11524 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11525 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11526 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11527 + | out
|
11528 + | }
|
11529 + | .into()]
|
11530 + | )
|
11531 + | .property("backend", "S3Express".to_string())
|
11532 + | .build()
|
11533 + | );
|
11534 + | }
|
11535 + |
|
11536 + | /// Data Plane with (14 char) zone and AP with FIPS and dualstack
|
11537 + | #[test]
|
11538 + | fn test_382() {
|
11539 + | let params = crate::config::endpoint::Params::builder()
|
11540 + | .region("us-west-2".to_string())
|
11541 + | .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
|
11542 + | .use_fips(true)
|
11543 + | .use_dual_stack(true)
|
11544 + | .accelerate(false)
|
11545 + | .use_s3_express_control_endpoint(false)
|
11546 + | .build()
|
11547 + | .expect("invalid params");
|
11548 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11549 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11550 + | let endpoint = endpoint.expect(
|
11551 + | "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
11552 + | );
|
11553 + | assert_eq!(
|
11554 + | endpoint,
|
11555 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11556 + | .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11557 + | .property(
|
11558 + | "authSchemes",
|
11559 + | vec![{
|
11560 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11561 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11562 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11563 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11564 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11565 + | out
|
11566 + | }
|
11567 + | .into()]
|
11568 + | )
|
11569 + | .property("backend", "S3Express".to_string())
|
11570 + | .build()
|
11571 + | );
|
11572 + | }
|
11573 + |
|
11574 + | /// Data Plane sigv4 auth with (14 char) zone and AP with dualstack
|
11575 + | #[test]
|
11576 + | fn test_383() {
|
11577 + | let params = crate::config::endpoint::Params::builder()
|
11578 + | .region("us-west-2".to_string())
|
11579 + | .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
|
11580 + | .use_fips(false)
|
11581 + | .use_dual_stack(true)
|
11582 + | .accelerate(false)
|
11583 + | .disable_s3_express_session_auth(true)
|
11584 + | .build()
|
11585 + | .expect("invalid params");
|
11586 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11587 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11588 + | let endpoint = endpoint.expect(
|
11589 + | "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
11590 + | );
|
11591 + | assert_eq!(
|
11592 + | endpoint,
|
11593 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11594 + | .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11595 + | .property(
|
11596 + | "authSchemes",
|
11597 + | vec![{
|
11598 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11599 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11600 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11601 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11602 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11603 + | out
|
11604 + | }
|
11605 + | .into()]
|
11606 + | )
|
11607 + | .property("backend", "S3Express".to_string())
|
11608 + | .build()
|
11609 + | );
|
11610 + | }
|
11611 + |
|
11612 + | /// Data Plane with (14 char) zone and AP with FIPS and dualstack
|
11613 + | #[test]
|
11614 + | fn test_384() {
|
11615 + | let params = crate::config::endpoint::Params::builder()
|
11616 + | .region("us-west-2".to_string())
|
11617 + | .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
|
11618 + | .use_fips(true)
|
11619 + | .use_dual_stack(true)
|
11620 + | .accelerate(false)
|
11621 + | .disable_s3_express_session_auth(true)
|
11622 + | .build()
|
11623 + | .expect("invalid params");
|
11624 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11625 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11626 + | let endpoint = endpoint.expect(
|
11627 + | "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
|
11628 + | );
|
11629 + | assert_eq!(
|
11630 + | endpoint,
|
11631 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11632 + | .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11633 + | .property(
|
11634 + | "authSchemes",
|
11635 + | vec![{
|
11636 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11637 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11638 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11639 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11640 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11641 + | out
|
11642 + | }
|
11643 + | .into()]
|
11644 + | )
|
11645 + | .property("backend", "S3Express".to_string())
|
11646 + | .build()
|
11647 + | );
|
11648 + | }
|
11649 + |
|
11650 + | /// Data Plane with (20 char) zone and AP with dualstack
|
11651 + | #[test]
|
11652 + | fn test_385() {
|
11653 + | let params = crate::config::endpoint::Params::builder()
|
11654 + | .region("us-west-2".to_string())
|
11655 + | .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
|
11656 + | .use_fips(false)
|
11657 + | .use_dual_stack(true)
|
11658 + | .accelerate(false)
|
11659 + | .use_s3_express_control_endpoint(false)
|
11660 + | .build()
|
11661 + | .expect("invalid params");
|
11662 + | let resolver = crate::config::endpoint::DefaultResolver::new();
|
11663 + | let endpoint = resolver.resolve_endpoint(¶ms);
|
11664 + | let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
11665 + | assert_eq!(
|
11666 + | endpoint,
|
11667 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11668 + | .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11669 + | .property(
|
11670 + | "authSchemes",
|
11671 + | vec![{
|
11672 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11673 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11674 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11675 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11676 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11677 + | out
|
11678 + | }
|
11679 + | .into()]
|
11680 + | )
|
11681 + | .property("backend", "S3Express".to_string())
|
11682 + | .build()
|
11683 + | );
|
11684 + | }
|
11685 + |
|
11686 + | /// Data Plane with (20 char) zone and AP with FIPS and dualstack
|
10158 11687 | #[test]
|
10159 - | fn test_344() {
|
11688 + | fn test_386() {
|
10160 11689 | let params = crate::config::endpoint::Params::builder()
|
10161 11690 | .region("us-west-2".to_string())
|
10162 - | .bucket("my.bucket--usw2-az1--x-s3".to_string())
|
10163 - | .use_fips(false)
|
10164 - | .use_dual_stack(false)
|
11691 + | .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
|
11692 + | .use_fips(true)
|
11693 + | .use_dual_stack(true)
|
10165 11694 | .accelerate(false)
|
10166 - | .endpoint("https://custom.com".to_string())
|
11695 + | .use_s3_express_control_endpoint(false)
|
10167 11696 | .build()
|
10168 11697 | .expect("invalid params");
|
10169 11698 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10170 11699 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10171 - | let error = endpoint.expect_err(
|
10172 - | "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
|
11700 + | let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
11701 + | assert_eq!(
|
11702 + | endpoint,
|
11703 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11704 + | .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11705 + | .property(
|
11706 + | "authSchemes",
|
11707 + | vec![{
|
11708 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11709 + | out.insert("name".to_string(), "sigv4-s3express".to_string().into());
|
11710 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11711 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11712 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11713 + | out
|
11714 + | }
|
11715 + | .into()]
|
11716 + | )
|
11717 + | .property("backend", "S3Express".to_string())
|
11718 + | .build()
|
10173 11719 | );
|
10174 - | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10175 11720 | }
|
10176 11721 |
|
10177 - | /// host override data plane AP error session auth
|
11722 + | /// Data plane AP with sigv4 and dualstack
|
10178 11723 | #[test]
|
10179 - | fn test_345() {
|
11724 + | fn test_387() {
|
10180 11725 | let params = crate::config::endpoint::Params::builder()
|
10181 11726 | .region("us-west-2".to_string())
|
10182 - | .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
|
11727 + | .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
|
10183 11728 | .use_fips(false)
|
10184 - | .use_dual_stack(false)
|
11729 + | .use_dual_stack(true)
|
10185 11730 | .accelerate(false)
|
10186 - | .endpoint("https://custom.com".to_string())
|
11731 + | .disable_s3_express_session_auth(true)
|
10187 11732 | .build()
|
10188 11733 | .expect("invalid params");
|
10189 11734 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10190 11735 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10191 - | let error = endpoint.expect_err(
|
10192 - | "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]",
|
11736 + | let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
11737 + | assert_eq!(
|
11738 + | endpoint,
|
11739 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11740 + | .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11741 + | .property(
|
11742 + | "authSchemes",
|
11743 + | vec![{
|
11744 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11745 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11746 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11747 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11748 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11749 + | out
|
11750 + | }
|
11751 + | .into()]
|
11752 + | )
|
11753 + | .property("backend", "S3Express".to_string())
|
11754 + | .build()
|
10193 11755 | );
|
10194 - | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
10195 11756 | }
|
10196 11757 |
|
10197 - | /// host override data plane bucket error
|
11758 + | /// Data plane AP sigv4 with fips and dualstack
|
10198 11759 | #[test]
|
10199 - | fn test_346() {
|
11760 + | fn test_388() {
|
10200 11761 | let params = crate::config::endpoint::Params::builder()
|
10201 11762 | .region("us-west-2".to_string())
|
10202 - | .bucket("my.bucket--usw2-az1--x-s3".to_string())
|
10203 - | .use_fips(false)
|
10204 - | .use_dual_stack(false)
|
11763 + | .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
|
11764 + | .use_fips(true)
|
11765 + | .use_dual_stack(true)
|
10205 11766 | .accelerate(false)
|
10206 - | .endpoint("https://custom.com".to_string())
|
10207 11767 | .disable_s3_express_session_auth(true)
|
10208 11768 | .build()
|
10209 11769 | .expect("invalid params");
|
10210 11770 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10211 11771 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10212 - | let error = endpoint
|
10213 - | .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
|
10214 - | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
11772 + | let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
|
11773 + | assert_eq!(
|
11774 + | endpoint,
|
11775 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11776 + | .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
|
11777 + | .property(
|
11778 + | "authSchemes",
|
11779 + | vec![{
|
11780 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11781 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11782 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11783 + | out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
|
11784 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11785 + | out
|
11786 + | }
|
11787 + | .into()]
|
11788 + | )
|
11789 + | .property("backend", "S3Express".to_string())
|
11790 + | .build()
|
11791 + | );
|
10215 11792 | }
|
10216 11793 |
|
10217 - | /// host override data plane AP error
|
11794 + | /// Control plane with dualstack and bucket
|
10218 11795 | #[test]
|
10219 - | fn test_347() {
|
11796 + | fn test_389() {
|
10220 11797 | let params = crate::config::endpoint::Params::builder()
|
10221 - | .region("us-west-2".to_string())
|
10222 - | .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
|
11798 + | .region("us-east-1".to_string())
|
11799 + | .bucket("mybucket--test-ab1--x-s3".to_string())
|
10223 11800 | .use_fips(false)
|
10224 - | .use_dual_stack(false)
|
11801 + | .use_dual_stack(true)
|
10225 11802 | .accelerate(false)
|
10226 - | .endpoint("https://custom.com".to_string())
|
10227 - | .disable_s3_express_session_auth(true)
|
11803 + | .use_s3_express_control_endpoint(true)
|
10228 11804 | .build()
|
10229 11805 | .expect("invalid params");
|
10230 11806 | let resolver = crate::config::endpoint::DefaultResolver::new();
|
10231 11807 | let endpoint = resolver.resolve_endpoint(¶ms);
|
10232 - | let error =
|
10233 - | endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error]");
|
10234 - | assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
|
11808 + | let endpoint =
|
11809 + | endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
|
11810 + | assert_eq!(
|
11811 + | endpoint,
|
11812 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
11813 + | .url("https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
|
11814 + | .property(
|
11815 + | "authSchemes",
|
11816 + | vec![{
|
11817 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
11818 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
11819 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
11820 + | out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
|
11821 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
11822 + | out
|
11823 + | }
|
11824 + | .into()]
|
11825 + | )
|
11826 + | .property("backend", "S3Express".to_string())
|
11827 + | .build()
|
11828 + | );
|
10235 11829 | }
|
10236 11830 | }
|
10237 11831 |
|
10238 11832 | /// Endpoint resolver trait specific to Amazon Simple Storage Service
|
10239 11833 | pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
|
10240 11834 | /// Resolve an endpoint with the given parameters
|
10241 11835 | fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
|
10242 11836 |
|
10243 11837 | /// Convert this service-specific resolver into a `SharedEndpointResolver`
|
10244 11838 | ///
|
10245 11839 | /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
|
10246 11840 | fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
|
10247 11841 | where
|
10248 11842 | Self: Sized + 'static,
|
10249 11843 | {
|
10250 11844 | ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
|
10251 11845 | }
|
10252 11846 | }
|
10253 11847 |
|
10254 11848 | #[derive(Debug)]
|
10255 11849 | struct DowncastParams<T>(T);
|
10256 11850 | impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
|
10257 11851 | where
|
10258 11852 | T: ResolveEndpoint,
|
10259 11853 | {
|
10260 11854 | fn resolve_endpoint<'a>(
|
10261 11855 | &'a self,
|
10262 11856 | params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
|
10263 11857 | ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
|
10264 11858 | let ep = match params.get::<crate::config::endpoint::Params>() {
|
10265 11859 | Some(params) => self.0.resolve_endpoint(params),
|
10266 11860 | None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
|
10267 11861 | };
|
10268 11862 | ep
|
10269 11863 | }
|
10270 11864 | }
|
10271 11865 |
|
10272 - | /// The default endpoint resolver
|
10273 - | #[derive(Debug, Default)]
|
11866 + | #[derive(Debug)]
|
11867 + | /// The default endpoint resolver.
|
10274 11868 | pub struct DefaultResolver {
|
10275 - | partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
|
11869 + | partition_resolver: &'static crate::endpoint_lib::partition::PartitionResolver,
|
11870 + | }
|
11871 + |
|
11872 + | impl Default for DefaultResolver {
|
11873 + | fn default() -> Self {
|
11874 + | Self::new()
|
11875 + | }
|
10276 11876 | }
|
10277 11877 |
|
10278 11878 | impl DefaultResolver {
|
10279 - | /// Create a new endpoint resolver with default settings
|
11879 + | /// Create a new DefaultResolver
|
10280 11880 | pub fn new() -> Self {
|
10281 11881 | Self {
|
10282 - | partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
|
11882 + | partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
|
10283 11883 | }
|
10284 11884 | }
|
10285 11885 |
|
10286 - | fn resolve_endpoint(
|
11886 + | #[allow(clippy::needless_borrow)]
|
11887 + | pub(crate) fn evaluate_fn(
|
10287 11888 | &self,
|
10288 - | params: &crate::config::endpoint::Params,
|
11889 + | ) -> impl for<'a> FnMut(&ConditionFn, &'a Params, &mut ConditionContext<'a>, &mut crate::endpoint_lib::diagnostic::DiagnosticCollector) -> bool + '_
|
11890 + | {
|
11891 + | move |cond, params, context, _diagnostic_collector| cond.evaluate(params, context, &self.partition_resolver, _diagnostic_collector)
|
11892 + | }
|
11893 + |
|
11894 + | fn resolve_endpoint<'a>(
|
11895 + | &'a self,
|
11896 + | params: &'a crate::config::endpoint::Params,
|
10289 11897 | ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
|
10290 11898 | let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
|
10291 - | Ok(
|
10292 - | crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
|
10293 - | .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
|
10294 - | )
|
11899 + | let mut condition_context = ConditionContext::default();
|
11900 + | let result = crate::endpoint_lib::bdd_interpreter::evaluate_bdd(
|
11901 + | &NODES,
|
11902 + | &CONDITIONS,
|
11903 + | &RESULTS,
|
11904 + | 521,
|
11905 + | params,
|
11906 + | &mut condition_context,
|
11907 + | &mut diagnostic_collector,
|
11908 + | self.evaluate_fn(),
|
11909 + | );
|
11910 + |
|
11911 + | match result {
|
11912 + | ::std::option::Option::Some(endpoint) => match endpoint.to_endpoint(params, &condition_context) {
|
11913 + | Ok(ep) => Ok(ep),
|
11914 + | Err(err) => Err(Box::new(err)),
|
11915 + | },
|
11916 + | ::std::option::Option::None => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
11917 + | "No endpoint rule matched",
|
11918 + | ))),
|
11919 + | }
|
10295 11920 | }
|
10296 11921 | }
|
10297 11922 |
|
10298 11923 | impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
|
10299 - | fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'_> {
|
10300 - | ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
|
11924 + | fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
|
11925 + | let result = self.resolve_endpoint(params);
|
11926 + |
|
11927 + | ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
|
11928 + | }
|
11929 + | }
|
11930 + | #[derive(Debug)]
|
11931 + | pub(crate) enum ConditionFn {
|
11932 + | Cond0,
|
11933 + | Cond1,
|
11934 + | Cond2,
|
11935 + | Cond3,
|
11936 + | Cond4,
|
11937 + | Cond5,
|
11938 + | Cond6,
|
11939 + | Cond7,
|
11940 + | Cond8,
|
11941 + | Cond9,
|
11942 + | Cond10,
|
11943 + | Cond11,
|
11944 + | Cond12,
|
11945 + | Cond13,
|
11946 + | Cond14,
|
11947 + | Cond15,
|
11948 + | Cond16,
|
11949 + | Cond17,
|
11950 + | Cond18,
|
11951 + | Cond19,
|
11952 + | Cond20,
|
11953 + | Cond21,
|
11954 + | Cond22,
|
11955 + | Cond23,
|
11956 + | Cond24,
|
11957 + | Cond25,
|
11958 + | Cond26,
|
11959 + | Cond27,
|
11960 + | Cond28,
|
11961 + | Cond29,
|
11962 + | Cond30,
|
11963 + | Cond31,
|
11964 + | Cond32,
|
11965 + | Cond33,
|
11966 + | Cond34,
|
11967 + | Cond35,
|
11968 + | Cond36,
|
11969 + | Cond37,
|
11970 + | Cond38,
|
11971 + | Cond39,
|
11972 + | Cond40,
|
11973 + | Cond41,
|
11974 + | Cond42,
|
11975 + | Cond43,
|
11976 + | Cond44,
|
11977 + | Cond45,
|
11978 + | Cond46,
|
11979 + | Cond47,
|
11980 + | Cond48,
|
11981 + | Cond49,
|
11982 + | Cond50,
|
11983 + | Cond51,
|
11984 + | Cond52,
|
11985 + | Cond53,
|
11986 + | Cond54,
|
11987 + | Cond55,
|
11988 + | Cond56,
|
11989 + | Cond57,
|
11990 + | Cond58,
|
11991 + | Cond59,
|
11992 + | Cond60,
|
11993 + | Cond61,
|
11994 + | Cond62,
|
11995 + | Cond63,
|
11996 + | Cond64,
|
11997 + | Cond65,
|
11998 + | Cond66,
|
11999 + | Cond67,
|
12000 + | Cond68,
|
12001 + | Cond69,
|
12002 + | Cond70,
|
12003 + | Cond71,
|
12004 + | Cond72,
|
12005 + | Cond73,
|
12006 + | Cond74,
|
12007 + | Cond75,
|
12008 + | }
|
12009 + |
|
12010 + | impl ConditionFn {
|
12011 + | #[allow(
|
12012 + | unused_variables,
|
12013 + | unused_parens,
|
12014 + | clippy::double_parens,
|
12015 + | clippy::useless_conversion,
|
12016 + | clippy::bool_comparison,
|
12017 + | clippy::comparison_to_empty,
|
12018 + | clippy::needless_borrow,
|
12019 + | clippy::useless_asref
|
12020 + | )]
|
12021 + | fn evaluate<'a>(
|
12022 + | &self,
|
12023 + | params: &'a Params,
|
12024 + | context: &mut ConditionContext<'a>,
|
12025 + | partition_resolver: &'a crate::endpoint_lib::partition::PartitionResolver,
|
12026 + | _diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector,
|
12027 + | ) -> bool {
|
12028 + | // Param bindings
|
12029 + | let bucket = ¶ms.bucket;
|
12030 + | let region = ¶ms.region;
|
12031 + | let use_fips = ¶ms.use_fips;
|
12032 + | let use_dual_stack = ¶ms.use_dual_stack;
|
12033 + | let endpoint = ¶ms.endpoint;
|
12034 + | let force_path_style = ¶ms.force_path_style;
|
12035 + | let accelerate = ¶ms.accelerate;
|
12036 + | let use_global_endpoint = ¶ms.use_global_endpoint;
|
12037 + | let use_object_lambda_endpoint = ¶ms.use_object_lambda_endpoint;
|
12038 + | let key = ¶ms.key;
|
12039 + | let prefix = ¶ms.prefix;
|
12040 + | let copy_source = ¶ms.copy_source;
|
12041 + | let disable_access_points = ¶ms.disable_access_points;
|
12042 + | let disable_multi_region_access_points = ¶ms.disable_multi_region_access_points;
|
12043 + | let use_arn_region = ¶ms.use_arn_region;
|
12044 + | let use_s3_express_control_endpoint = ¶ms.use_s3_express_control_endpoint;
|
12045 + | let disable_s3_express_session_auth = ¶ms.disable_s3_express_session_auth;
|
12046 + |
|
12047 + | // Non-Param references
|
12048 + | let effective_std_region = &mut context.effective_std_region;
|
12049 + | let partition_result = &mut context.partition_result;
|
12050 + | let url = &mut context.url;
|
12051 + | let access_point_suffix = &mut context.access_point_suffix;
|
12052 + | let region_prefix = &mut context.region_prefix;
|
12053 + | let hardware_type = &mut context.hardware_type;
|
12054 + | let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
|
12055 + | let s3_e_ds = &mut context.s3_e_ds;
|
12056 + | let s3_e_fips = &mut context.s3_e_fips;
|
12057 + | let s3_e_auth = &mut context.s3_e_auth;
|
12058 + | let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
|
12059 + | let bucket_arn = &mut context.bucket_arn;
|
12060 + | let effective_arn_region = &mut context.effective_arn_region;
|
12061 + | let uri_encoded_bucket = &mut context.uri_encoded_bucket;
|
12062 + | let arn_type = &mut context.arn_type;
|
12063 + | let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
|
12064 + | let bucket_partition = &mut context.bucket_partition;
|
12065 + | let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
|
12066 + | let outpost_type = &mut context.outpost_type;
|
12067 + | let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
|
12068 + | match self {
|
12069 + | Self::Cond0 => region.is_some(),
|
12070 + | Self::Cond1 => {
|
12071 + | *effective_std_region = Some(
|
12072 + | crate::endpoint_lib::ite::ite!(
|
12073 + | (region) == &mut Some(("aws-global".into())),
|
12074 + | "us-east-1".to_string(),
|
12075 + | region.clone().expect("Reference already confirmed Some")
|
12076 + | )
|
12077 + | .into(),
|
12078 + | );
|
12079 + | true
|
12080 + | }
|
12081 + | Self::Cond2 => (accelerate) == (&true),
|
12082 + | Self::Cond3 => (use_fips) == (&true),
|
12083 + | Self::Cond4 => endpoint.is_some(),
|
12084 + | Self::Cond5 => (use_dual_stack) == (&true),
|
12085 + | Self::Cond6 => bucket.is_some(),
|
12086 + | Self::Cond7 => {
|
12087 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12088 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12089 + | if let Some(param) = bucket { param } else { return false },
|
12090 + | 0,
|
12091 + | 6,
|
12092 + | true,
|
12093 + | _diagnostic_collector
|
12094 + | ) {
|
12095 + | inner
|
12096 + | } else {
|
12097 + | return false;
|
12098 + | },
|
12099 + | ""
|
12100 + | )) == ("--x-s3")
|
12101 + | }
|
12102 + | Self::Cond8 => {
|
12103 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12104 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12105 + | if let Some(param) = bucket { param } else { return false },
|
12106 + | 0,
|
12107 + | 7,
|
12108 + | true,
|
12109 + | _diagnostic_collector
|
12110 + | ) {
|
12111 + | inner
|
12112 + | } else {
|
12113 + | return false;
|
12114 + | },
|
12115 + | ""
|
12116 + | )) == ("--xa-s3")
|
12117 + | }
|
12118 + | Self::Cond9 => {
|
12119 + | *partition_result = partition_resolver
|
12120 + | .resolve_partition(if let Some(param) = region { param } else { return false }, _diagnostic_collector)
|
12121 + | .map(|inner| inner.into());
|
12122 + | partition_result.is_some()
|
12123 + | }
|
12124 + | Self::Cond10 => {
|
12125 + | *url =
|
12126 + | crate::endpoint_lib::parse_url::parse_url(if let Some(param) = endpoint { param } else { return false }, _diagnostic_collector)
|
12127 + | .map(|inner| inner.into());
|
12128 + | url.is_some()
|
12129 + | }
|
12130 + | Self::Cond11 => {
|
12131 + | *access_point_suffix = crate::endpoint_lib::substring::substring(
|
12132 + | if let Some(param) = bucket { param } else { return false },
|
12133 + | 0,
|
12134 + | 7,
|
12135 + | true,
|
12136 + | _diagnostic_collector,
|
12137 + | )
|
12138 + | .map(|inner| inner.into());
|
12139 + | access_point_suffix.is_some()
|
12140 + | }
|
12141 + | Self::Cond12 => (access_point_suffix) == &mut Some(("--op-s3".into())),
|
12142 + | Self::Cond13 => {
|
12143 + | *region_prefix = crate::endpoint_lib::substring::substring(
|
12144 + | if let Some(param) = bucket { param } else { return false },
|
12145 + | 8,
|
12146 + | 12,
|
12147 + | true,
|
12148 + | _diagnostic_collector,
|
12149 + | )
|
12150 + | .map(|inner| inner.into());
|
12151 + | region_prefix.is_some()
|
12152 + | }
|
12153 + | Self::Cond14 => {
|
12154 + | *hardware_type = crate::endpoint_lib::substring::substring(
|
12155 + | if let Some(param) = bucket { param } else { return false },
|
12156 + | 49,
|
12157 + | 50,
|
12158 + | true,
|
12159 + | _diagnostic_collector,
|
12160 + | )
|
12161 + | .map(|inner| inner.into());
|
12162 + | hardware_type.is_some()
|
12163 + | }
|
12164 + | Self::Cond15 => {
|
12165 + | *outpost_id_ssa_2 = crate::endpoint_lib::substring::substring(
|
12166 + | if let Some(param) = bucket { param } else { return false },
|
12167 + | 32,
|
12168 + | 49,
|
12169 + | true,
|
12170 + | _diagnostic_collector,
|
12171 + | )
|
12172 + | .map(|inner| inner.into());
|
12173 + | outpost_id_ssa_2.is_some()
|
12174 + | }
|
12175 + | Self::Cond16 => {
|
12176 + | (if let Some(inner) = partition_result {
|
12177 + | inner.name()
|
12178 + | } else {
|
12179 + | return false;
|
12180 + | }) == ("aws-cn")
|
12181 + | }
|
12182 + | Self::Cond17 => {
|
12183 + | *s3_e_ds = Some(crate::endpoint_lib::ite::ite!(use_dual_stack, ".dualstack".to_string(), "".to_string()).into());
|
12184 + | true
|
12185 + | }
|
12186 + | Self::Cond18 => {
|
12187 + | *s3_e_fips = Some(crate::endpoint_lib::ite::ite!(use_fips, "-fips".to_string(), "".to_string()).into());
|
12188 + | true
|
12189 + | }
|
12190 + | Self::Cond19 => (force_path_style) == (&true),
|
12191 + | Self::Cond20 => {
|
12192 + | *s3_e_auth = Some(
|
12193 + | crate::endpoint_lib::ite::ite!(
|
12194 + | crate::endpoint_lib::coalesce::coalesce!(*disable_s3_express_session_auth, false),
|
12195 + | "sigv4".to_string(),
|
12196 + | "sigv4-s3express".to_string()
|
12197 + | )
|
12198 + | .into(),
|
12199 + | );
|
12200 + | true
|
12201 + | }
|
12202 + | Self::Cond21 => crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
|
12203 + | if let Some(param) = bucket { param } else { return false },
|
12204 + | false,
|
12205 + | _diagnostic_collector,
|
12206 + | ),
|
12207 + | Self::Cond22 => {
|
12208 + | *s3express_availability_zone_id = crate::endpoint_lib::split::split(
|
12209 + | if let Some(param) = bucket { param } else { return false },
|
12210 + | "--",
|
12211 + | 0,
|
12212 + | _diagnostic_collector,
|
12213 + | )
|
12214 + | .get(1)
|
12215 + | .cloned()
|
12216 + | .map(|inner| inner.into());
|
12217 + | s3express_availability_zone_id.is_some()
|
12218 + | }
|
12219 + | Self::Cond23 => crate::endpoint_lib::host::is_valid_host_label(
|
12220 + | if let Some(param) = outpost_id_ssa_2 { param } else { return false },
|
12221 + | false,
|
12222 + | _diagnostic_collector,
|
12223 + | ),
|
12224 + | Self::Cond24 => (crate::endpoint_lib::coalesce::coalesce!(*use_s3_express_control_endpoint, false)) == (true),
|
12225 + | Self::Cond25 => (region_prefix) == &mut Some(("beta".into())),
|
12226 + | Self::Cond26 => crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
|
12227 + | if let Some(param) = bucket { param } else { return false },
|
12228 + | true,
|
12229 + | _diagnostic_collector,
|
12230 + | ),
|
12231 + | Self::Cond27 => {
|
12232 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12233 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12234 + | if let Some(param) = bucket { param } else { return false },
|
12235 + | 16,
|
12236 + | 18,
|
12237 + | true,
|
12238 + | _diagnostic_collector
|
12239 + | ) {
|
12240 + | inner
|
12241 + | } else {
|
12242 + | return false;
|
12243 + | },
|
12244 + | ""
|
12245 + | )) == ("--")
|
12246 + | }
|
12247 + | Self::Cond28 => {
|
12248 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12249 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12250 + | if let Some(param) = bucket { param } else { return false },
|
12251 + | 21,
|
12252 + | 23,
|
12253 + | true,
|
12254 + | _diagnostic_collector
|
12255 + | ) {
|
12256 + | inner
|
12257 + | } else {
|
12258 + | return false;
|
12259 + | },
|
12260 + | ""
|
12261 + | )) == ("--")
|
12262 + | }
|
12263 + | Self::Cond29 => (if let Some(inner) = url { inner.scheme() } else { return false }) == ("http"),
|
12264 + | Self::Cond30 => crate::endpoint_lib::host::is_valid_host_label(
|
12265 + | if let Some(param) = region { param } else { return false },
|
12266 + | false,
|
12267 + | _diagnostic_collector,
|
12268 + | ),
|
12269 + | Self::Cond31 => {
|
12270 + | *bucket_arn = crate::endpoint_lib::arn::parse_arn(if let Some(param) = bucket { param } else { return false }, _diagnostic_collector)
|
12271 + | .map(|inner| inner.into());
|
12272 + | bucket_arn.is_some()
|
12273 + | }
|
12274 + | Self::Cond32 => {
|
12275 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12276 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12277 + | if let Some(param) = bucket { param } else { return false },
|
12278 + | 27,
|
12279 + | 29,
|
12280 + | true,
|
12281 + | _diagnostic_collector
|
12282 + | ) {
|
12283 + | inner
|
12284 + | } else {
|
12285 + | return false;
|
12286 + | },
|
12287 + | ""
|
12288 + | )) == ("--")
|
12289 + | }
|
12290 + | Self::Cond33 => {
|
12291 + | *effective_arn_region = Some(
|
12292 + | crate::endpoint_lib::ite::ite!(
|
12293 + | crate::endpoint_lib::coalesce::coalesce!(*use_arn_region, true),
|
12294 + | if let Some(inner) = bucket_arn { inner.region() } else { return false }.to_string(),
|
12295 + | region.clone().expect("Reference already confirmed Some")
|
12296 + | )
|
12297 + | .into(),
|
12298 + | );
|
12299 + | true
|
12300 + | }
|
12301 + | Self::Cond34 => (if let Some(inner) = url { inner.is_ip() } else { return false }) == (true),
|
12302 + | Self::Cond35 => {
|
12303 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12304 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12305 + | if let Some(param) = bucket { param } else { return false },
|
12306 + | 0,
|
12307 + | 4,
|
12308 + | false,
|
12309 + | _diagnostic_collector
|
12310 + | ) {
|
12311 + | inner
|
12312 + | } else {
|
12313 + | return false;
|
12314 + | },
|
12315 + | ""
|
12316 + | )) == ("arn:")
|
12317 + | }
|
12318 + | Self::Cond36 => {
|
12319 + | *uri_encoded_bucket = Some(
|
12320 + | crate::endpoint_lib::uri_encode::uri_encode(if let Some(param) = bucket { param } else { return false }, _diagnostic_collector)
|
12321 + | .into(),
|
12322 + | );
|
12323 + | true
|
12324 + | }
|
12325 + | Self::Cond37 => (crate::endpoint_lib::coalesce::coalesce!(*use_object_lambda_endpoint, false)) == (true),
|
12326 + | Self::Cond38 => {
|
12327 + | *arn_type = if let Some(inner) = bucket_arn {
|
12328 + | inner.resource_id().first().cloned()
|
12329 + | } else {
|
12330 + | return false;
|
12331 + | }
|
12332 + | .map(|inner| inner.into());
|
12333 + | arn_type.is_some()
|
12334 + | }
|
12335 + | Self::Cond39 => (arn_type) == &mut Some(("".into())),
|
12336 + | Self::Cond40 => (arn_type) == &mut Some(("accesspoint".into())),
|
12337 + | Self::Cond41 => {
|
12338 + | *access_point_name_ssa_1 = if let Some(inner) = bucket_arn {
|
12339 + | inner.resource_id().get(1).cloned()
|
12340 + | } else {
|
12341 + | return false;
|
12342 + | }
|
12343 + | .map(|inner| inner.into());
|
12344 + | access_point_name_ssa_1.is_some()
|
12345 + | }
|
12346 + | Self::Cond42 => (access_point_name_ssa_1) == &mut Some(("".into())),
|
12347 + | Self::Cond43 => (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-object-lambda"),
|
12348 + | Self::Cond44 => crate::endpoint_lib::host::is_valid_host_label(
|
12349 + | if let Some(param) = region { param } else { return false },
|
12350 + | true,
|
12351 + | _diagnostic_collector,
|
12352 + | ),
|
12353 + | Self::Cond45 => (if let Some(inner) = bucket_arn { inner.region() } else { return false }) == (""),
|
12354 + | Self::Cond46 => (hardware_type) == &mut Some(("e".into())),
|
12355 + | Self::Cond47 => {
|
12356 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12357 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12358 + | if let Some(param) = bucket { param } else { return false },
|
12359 + | 26,
|
12360 + | 28,
|
12361 + | true,
|
12362 + | _diagnostic_collector
|
12363 + | ) {
|
12364 + | inner
|
12365 + | } else {
|
12366 + | return false;
|
12367 + | },
|
12368 + | ""
|
12369 + | )) == ("--")
|
12370 + | }
|
12371 + | Self::Cond48 => {
|
12372 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12373 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12374 + | if let Some(param) = bucket { param } else { return false },
|
12375 + | 19,
|
12376 + | 21,
|
12377 + | true,
|
12378 + | _diagnostic_collector
|
12379 + | ) {
|
12380 + | inner
|
12381 + | } else {
|
12382 + | return false;
|
12383 + | },
|
12384 + | ""
|
12385 + | )) == ("--")
|
12386 + | }
|
12387 + | Self::Cond49 => {
|
12388 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12389 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12390 + | if let Some(param) = bucket { param } else { return false },
|
12391 + | 14,
|
12392 + | 16,
|
12393 + | true,
|
12394 + | _diagnostic_collector
|
12395 + | ) {
|
12396 + | inner
|
12397 + | } else {
|
12398 + | return false;
|
12399 + | },
|
12400 + | ""
|
12401 + | )) == ("--")
|
12402 + | }
|
12403 + | Self::Cond50 => {
|
12404 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12405 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12406 + | if let Some(param) = bucket { param } else { return false },
|
12407 + | 20,
|
12408 + | 22,
|
12409 + | true,
|
12410 + | _diagnostic_collector
|
12411 + | ) {
|
12412 + | inner
|
12413 + | } else {
|
12414 + | return false;
|
12415 + | },
|
12416 + | ""
|
12417 + | )) == ("--")
|
12418 + | }
|
12419 + | Self::Cond51 => {
|
12420 + | (crate::endpoint_lib::coalesce::coalesce!(
|
12421 + | if let Some(inner) = crate::endpoint_lib::substring::substring(
|
12422 + | if let Some(param) = bucket { param } else { return false },
|
12423 + | 15,
|
12424 + | 17,
|
12425 + | true,
|
12426 + | _diagnostic_collector
|
12427 + | ) {
|
12428 + | inner
|
12429 + | } else {
|
12430 + | return false;
|
12431 + | },
|
12432 + | ""
|
12433 + | )) == ("--")
|
12434 + | }
|
12435 + | Self::Cond52 => (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-outposts"),
|
12436 + | Self::Cond53 => (crate::endpoint_lib::coalesce::coalesce!(*disable_access_points, false)) == (true),
|
12437 + | Self::Cond54 => {
|
12438 + | *bucket_partition = partition_resolver
|
12439 + | .resolve_partition(
|
12440 + | if let Some(param) = effective_arn_region { param } else { return false },
|
12441 + | _diagnostic_collector,
|
12442 + | )
|
12443 + | .map(|inner| inner.into());
|
12444 + | bucket_partition.is_some()
|
12445 + | }
|
12446 + | Self::Cond55 => (hardware_type) == &mut Some(("o".into())),
|
12447 + | Self::Cond56 => if let Some(inner) = bucket_arn {
|
12448 + | inner.resource_id().get(4).cloned()
|
12449 + | } else {
|
12450 + | return false;
|
12451 + | }
|
12452 + | .is_some(),
|
12453 + | Self::Cond57 => {
|
12454 + | *outpost_id_ssa_1 = if let Some(inner) = bucket_arn {
|
12455 + | inner.resource_id().get(1).cloned()
|
12456 + | } else {
|
12457 + | return false;
|
12458 + | }
|
12459 + | .map(|inner| inner.into());
|
12460 + | outpost_id_ssa_1.is_some()
|
12461 + | }
|
12462 + | Self::Cond58 => (crate::endpoint_lib::coalesce::coalesce!(*use_arn_region, true)) == (true),
|
12463 + | Self::Cond59 => (effective_arn_region) == &mut Some((if let Some(inner) = bucket_arn { inner.region() } else { return false }.into())),
|
12464 + | Self::Cond60 => (region) == &mut Some(("aws-global".into())),
|
12465 + | Self::Cond61 => (use_global_endpoint) == (&true),
|
12466 + | Self::Cond62 => (disable_multi_region_access_points) == (&true),
|
12467 + | Self::Cond63 => (region) == &mut Some(("us-east-1".into())),
|
12468 + | Self::Cond64 => crate::endpoint_lib::host::is_valid_host_label(
|
12469 + | if let Some(param) = outpost_id_ssa_1 { param } else { return false },
|
12470 + | false,
|
12471 + | _diagnostic_collector,
|
12472 + | ),
|
12473 + | Self::Cond65 => {
|
12474 + | *outpost_type = if let Some(inner) = bucket_arn {
|
12475 + | inner.resource_id().get(2).cloned()
|
12476 + | } else {
|
12477 + | return false;
|
12478 + | }
|
12479 + | .map(|inner| inner.into());
|
12480 + | outpost_type.is_some()
|
12481 + | }
|
12482 + | Self::Cond66 => {
|
12483 + | (if let Some(inner) = bucket_partition {
|
12484 + | inner.name()
|
12485 + | } else {
|
12486 + | return false;
|
12487 + | }) == (if let Some(inner) = partition_result {
|
12488 + | inner.name()
|
12489 + | } else {
|
12490 + | return false;
|
12491 + | })
|
12492 + | }
|
12493 + | Self::Cond67 => crate::endpoint_lib::host::is_valid_host_label(
|
12494 + | if let Some(param) = effective_arn_region { param } else { return false },
|
12495 + | true,
|
12496 + | _diagnostic_collector,
|
12497 + | ),
|
12498 + | Self::Cond68 => (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3"),
|
12499 + | Self::Cond69 => {
|
12500 + | (if let Some(inner) = bucket_arn {
|
12501 + | inner.account_id()
|
12502 + | } else {
|
12503 + | return false;
|
12504 + | }) == ("")
|
12505 + | }
|
12506 + | Self::Cond70 => crate::endpoint_lib::host::is_valid_host_label(
|
12507 + | if let Some(inner) = bucket_arn {
|
12508 + | inner.account_id()
|
12509 + | } else {
|
12510 + | return false;
|
12511 + | },
|
12512 + | false,
|
12513 + | _diagnostic_collector,
|
12514 + | ),
|
12515 + | Self::Cond71 => crate::endpoint_lib::host::is_valid_host_label(
|
12516 + | if let Some(param) = access_point_name_ssa_1 {
|
12517 + | param
|
12518 + | } else {
|
12519 + | return false;
|
12520 + | },
|
12521 + | false,
|
12522 + | _diagnostic_collector,
|
12523 + | ),
|
12524 + | Self::Cond72 => {
|
12525 + | *access_point_name_ssa_2 = if let Some(inner) = bucket_arn {
|
12526 + | inner.resource_id().get(3).cloned()
|
12527 + | } else {
|
12528 + | return false;
|
12529 + | }
|
12530 + | .map(|inner| inner.into());
|
12531 + | access_point_name_ssa_2.is_some()
|
12532 + | }
|
12533 + | Self::Cond73 => crate::endpoint_lib::host::is_valid_host_label(
|
12534 + | if let Some(param) = access_point_name_ssa_1 {
|
12535 + | param
|
12536 + | } else {
|
12537 + | return false;
|
12538 + | },
|
12539 + | true,
|
12540 + | _diagnostic_collector,
|
12541 + | ),
|
12542 + | Self::Cond74 => {
|
12543 + | (if let Some(inner) = bucket_arn { inner.partition() } else { return false })
|
12544 + | == (if let Some(inner) = partition_result {
|
12545 + | inner.name()
|
12546 + | } else {
|
12547 + | return false;
|
12548 + | })
|
12549 + | }
|
12550 + | Self::Cond75 => (outpost_type) == &mut Some(("accesspoint".into())),
|
12551 + | }
|
12552 + | }
|
12553 + | }
|
12554 + |
|
12555 + | const CONDITIONS: [ConditionFn; 76] = [
|
12556 + | ConditionFn::Cond0,
|
12557 + | ConditionFn::Cond1,
|
12558 + | ConditionFn::Cond2,
|
12559 + | ConditionFn::Cond3,
|
12560 + | ConditionFn::Cond4,
|
12561 + | ConditionFn::Cond5,
|
12562 + | ConditionFn::Cond6,
|
12563 + | ConditionFn::Cond7,
|
12564 + | ConditionFn::Cond8,
|
12565 + | ConditionFn::Cond9,
|
12566 + | ConditionFn::Cond10,
|
12567 + | ConditionFn::Cond11,
|
12568 + | ConditionFn::Cond12,
|
12569 + | ConditionFn::Cond13,
|
12570 + | ConditionFn::Cond14,
|
12571 + | ConditionFn::Cond15,
|
12572 + | ConditionFn::Cond16,
|
12573 + | ConditionFn::Cond17,
|
12574 + | ConditionFn::Cond18,
|
12575 + | ConditionFn::Cond19,
|
12576 + | ConditionFn::Cond20,
|
12577 + | ConditionFn::Cond21,
|
12578 + | ConditionFn::Cond22,
|
12579 + | ConditionFn::Cond23,
|
12580 + | ConditionFn::Cond24,
|
12581 + | ConditionFn::Cond25,
|
12582 + | ConditionFn::Cond26,
|
12583 + | ConditionFn::Cond27,
|
12584 + | ConditionFn::Cond28,
|
12585 + | ConditionFn::Cond29,
|
12586 + | ConditionFn::Cond30,
|
12587 + | ConditionFn::Cond31,
|
12588 + | ConditionFn::Cond32,
|
12589 + | ConditionFn::Cond33,
|
12590 + | ConditionFn::Cond34,
|
12591 + | ConditionFn::Cond35,
|
12592 + | ConditionFn::Cond36,
|
12593 + | ConditionFn::Cond37,
|
12594 + | ConditionFn::Cond38,
|
12595 + | ConditionFn::Cond39,
|
12596 + | ConditionFn::Cond40,
|
12597 + | ConditionFn::Cond41,
|
12598 + | ConditionFn::Cond42,
|
12599 + | ConditionFn::Cond43,
|
12600 + | ConditionFn::Cond44,
|
12601 + | ConditionFn::Cond45,
|
12602 + | ConditionFn::Cond46,
|
12603 + | ConditionFn::Cond47,
|
12604 + | ConditionFn::Cond48,
|
12605 + | ConditionFn::Cond49,
|
12606 + | ConditionFn::Cond50,
|
12607 + | ConditionFn::Cond51,
|
12608 + | ConditionFn::Cond52,
|
12609 + | ConditionFn::Cond53,
|
12610 + | ConditionFn::Cond54,
|
12611 + | ConditionFn::Cond55,
|
12612 + | ConditionFn::Cond56,
|
12613 + | ConditionFn::Cond57,
|
12614 + | ConditionFn::Cond58,
|
12615 + | ConditionFn::Cond59,
|
12616 + | ConditionFn::Cond60,
|
12617 + | ConditionFn::Cond61,
|
12618 + | ConditionFn::Cond62,
|
12619 + | ConditionFn::Cond63,
|
12620 + | ConditionFn::Cond64,
|
12621 + | ConditionFn::Cond65,
|
12622 + | ConditionFn::Cond66,
|
12623 + | ConditionFn::Cond67,
|
12624 + | ConditionFn::Cond68,
|
12625 + | ConditionFn::Cond69,
|
12626 + | ConditionFn::Cond70,
|
12627 + | ConditionFn::Cond71,
|
12628 + | ConditionFn::Cond72,
|
12629 + | ConditionFn::Cond73,
|
12630 + | ConditionFn::Cond74,
|
12631 + | ConditionFn::Cond75,
|
12632 + | ];
|
12633 + | #[derive(Debug, Clone)]
|
12634 + | enum ResultEndpoint {
|
12635 + | Result0,
|
12636 + | Result1,
|
12637 + | Result2,
|
12638 + | Result3,
|
12639 + | Result4,
|
12640 + | Result5,
|
12641 + | Result6,
|
12642 + | Result7,
|
12643 + | Result8,
|
12644 + | Result9,
|
12645 + | Result10,
|
12646 + | Result11,
|
12647 + | Result12,
|
12648 + | Result13,
|
12649 + | Result14,
|
12650 + | Result15,
|
12651 + | Result16,
|
12652 + | Result17,
|
12653 + | Result18,
|
12654 + | Result19,
|
12655 + | Result20,
|
12656 + | Result21,
|
12657 + | Result22,
|
12658 + | Result23,
|
12659 + | Result24,
|
12660 + | Result25,
|
12661 + | Result26,
|
12662 + | Result27,
|
12663 + | Result28,
|
12664 + | Result29,
|
12665 + | Result30,
|
12666 + | Result31,
|
12667 + | Result32,
|
12668 + | Result33,
|
12669 + | Result34,
|
12670 + | Result35,
|
12671 + | Result36,
|
12672 + | Result37,
|
12673 + | Result38,
|
12674 + | Result39,
|
12675 + | Result40,
|
12676 + | Result41,
|
12677 + | Result42,
|
12678 + | Result43,
|
12679 + | Result44,
|
12680 + | Result45,
|
12681 + | Result46,
|
12682 + | Result47,
|
12683 + | Result48,
|
12684 + | Result49,
|
12685 + | Result50,
|
12686 + | Result51,
|
12687 + | Result52,
|
12688 + | Result53,
|
12689 + | Result54,
|
12690 + | Result55,
|
12691 + | Result56,
|
12692 + | Result57,
|
12693 + | Result58,
|
12694 + | Result59,
|
12695 + | Result60,
|
12696 + | Result61,
|
12697 + | Result62,
|
12698 + | Result63,
|
12699 + | Result64,
|
12700 + | Result65,
|
12701 + | Result66,
|
12702 + | Result67,
|
12703 + | Result68,
|
12704 + | Result69,
|
12705 + | Result70,
|
12706 + | Result71,
|
12707 + | Result72,
|
12708 + | Result73,
|
12709 + | Result74,
|
12710 + | Result75,
|
12711 + | Result76,
|
12712 + | Result77,
|
12713 + | Result78,
|
12714 + | Result79,
|
12715 + | Result80,
|
12716 + | Result81,
|
12717 + | Result82,
|
12718 + | Result83,
|
12719 + | Result84,
|
12720 + | Result85,
|
12721 + | Result86,
|
12722 + | Result87,
|
12723 + | Result88,
|
12724 + | Result89,
|
12725 + | Result90,
|
12726 + | Result91,
|
12727 + | Result92,
|
12728 + | Result93,
|
12729 + | Result94,
|
12730 + | Result95,
|
12731 + | Result96,
|
12732 + | }
|
12733 + |
|
12734 + | impl<'a> ResultEndpoint {
|
12735 + | #[allow(unused_variables, clippy::useless_asref)]
|
12736 + | fn to_endpoint(
|
12737 + | &self,
|
12738 + | params: &'a Params,
|
12739 + | context: &ConditionContext<'a>,
|
12740 + | ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_http::endpoint::ResolveEndpointError> {
|
12741 + | match self {
|
12742 + | Self::Result0 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched")),
|
12743 + | Self::Result1 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12744 + | "Accelerate cannot be used with FIPS".to_string(),
|
12745 + | )),
|
12746 + | Self::Result2 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12747 + | "Cannot set dual-stack in combination with a custom endpoint.".to_string(),
|
12748 + | )),
|
12749 + | Self::Result3 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12750 + | "A custom endpoint cannot be combined with FIPS".to_string(),
|
12751 + | )),
|
12752 + | Self::Result4 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12753 + | "A custom endpoint cannot be combined with S3 Accelerate".to_string(),
|
12754 + | )),
|
12755 + | Self::Result5 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12756 + | "Partition does not support FIPS".to_string(),
|
12757 + | )),
|
12758 + | Self::Result6 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12759 + | "S3Express does not support S3 Accelerate.".to_string(),
|
12760 + | )),
|
12761 + | Self::Result7 => {
|
12762 + | let effective_std_region = context
|
12763 + | .effective_std_region
|
12764 + | .as_ref()
|
12765 + | .map(|s| s.clone())
|
12766 + | .expect("Guaranteed to have a value by earlier checks.");
|
12767 + | let url = context
|
12768 + | .url
|
12769 + | .as_ref()
|
12770 + | .map(|s| s.clone())
|
12771 + | .expect("Guaranteed to have a value by earlier checks.");
|
12772 + | let s3_e_auth = context
|
12773 + | .s3_e_auth
|
12774 + | .as_ref()
|
12775 + | .map(|s| s.clone())
|
12776 + | .expect("Guaranteed to have a value by earlier checks.");
|
12777 + | let uri_encoded_bucket = context
|
12778 + | .uri_encoded_bucket
|
12779 + | .as_ref()
|
12780 + | .map(|s| s.clone())
|
12781 + | .expect("Guaranteed to have a value by earlier checks.");
|
12782 + | ::std::result::Result::Ok(
|
12783 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
12784 + | .url({
|
12785 + | let mut out = String::new();
|
12786 + | #[allow(clippy::needless_borrow)]
|
12787 + | out.push_str(&url.scheme());
|
12788 + | out.push_str("://");
|
12789 + | #[allow(clippy::needless_borrow)]
|
12790 + | out.push_str(&url.authority());
|
12791 + | out.push('/');
|
12792 + | #[allow(clippy::needless_borrow)]
|
12793 + | out.push_str(&uri_encoded_bucket.as_ref());
|
12794 + | #[allow(clippy::needless_borrow)]
|
12795 + | out.push_str(&url.path());
|
12796 + | out
|
12797 + | })
|
12798 + | .property("backend", "S3Express".to_string())
|
12799 + | .property(
|
12800 + | "authSchemes",
|
12801 + | vec![::aws_smithy_types::Document::from({
|
12802 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
12803 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
12804 + | out.insert("name".to_string(), s3_e_auth.to_owned().into());
|
12805 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
12806 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
12807 + | out
|
12808 + | })],
|
12809 + | )
|
12810 + | .build(),
|
12811 + | )
|
12812 + | }
|
12813 + | Self::Result8 => {
|
12814 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
12815 + | let effective_std_region = context
|
12816 + | .effective_std_region
|
12817 + | .as_ref()
|
12818 + | .map(|s| s.clone())
|
12819 + | .expect("Guaranteed to have a value by earlier checks.");
|
12820 + | let url = context
|
12821 + | .url
|
12822 + | .as_ref()
|
12823 + | .map(|s| s.clone())
|
12824 + | .expect("Guaranteed to have a value by earlier checks.");
|
12825 + | let s3_e_auth = context
|
12826 + | .s3_e_auth
|
12827 + | .as_ref()
|
12828 + | .map(|s| s.clone())
|
12829 + | .expect("Guaranteed to have a value by earlier checks.");
|
12830 + | ::std::result::Result::Ok(
|
12831 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
12832 + | .url({
|
12833 + | let mut out = String::new();
|
12834 + | #[allow(clippy::needless_borrow)]
|
12835 + | out.push_str(&url.scheme());
|
12836 + | out.push_str("://");
|
12837 + | #[allow(clippy::needless_borrow)]
|
12838 + | out.push_str(&bucket.as_ref());
|
12839 + | out.push('.');
|
12840 + | #[allow(clippy::needless_borrow)]
|
12841 + | out.push_str(&url.authority());
|
12842 + | #[allow(clippy::needless_borrow)]
|
12843 + | out.push_str(&url.path());
|
12844 + | out
|
12845 + | })
|
12846 + | .property("backend", "S3Express".to_string())
|
12847 + | .property(
|
12848 + | "authSchemes",
|
12849 + | vec![::aws_smithy_types::Document::from({
|
12850 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
12851 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
12852 + | out.insert("name".to_string(), s3_e_auth.to_owned().into());
|
12853 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
12854 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
12855 + | out
|
12856 + | })],
|
12857 + | )
|
12858 + | .build(),
|
12859 + | )
|
12860 + | }
|
12861 + | Self::Result9 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12862 + | "S3Express bucket name is not a valid virtual hostable name.".to_string(),
|
12863 + | )),
|
12864 + | Self::Result10 => {
|
12865 + | let effective_std_region = context
|
12866 + | .effective_std_region
|
12867 + | .as_ref()
|
12868 + | .map(|s| s.clone())
|
12869 + | .expect("Guaranteed to have a value by earlier checks.");
|
12870 + | let partition_result = context
|
12871 + | .partition_result
|
12872 + | .as_ref()
|
12873 + | .map(|s| s.clone())
|
12874 + | .expect("Guaranteed to have a value by earlier checks.");
|
12875 + | let s3_e_ds = context
|
12876 + | .s3_e_ds
|
12877 + | .as_ref()
|
12878 + | .map(|s| s.clone())
|
12879 + | .expect("Guaranteed to have a value by earlier checks.");
|
12880 + | let s3_e_fips = context
|
12881 + | .s3_e_fips
|
12882 + | .as_ref()
|
12883 + | .map(|s| s.clone())
|
12884 + | .expect("Guaranteed to have a value by earlier checks.");
|
12885 + | let uri_encoded_bucket = context
|
12886 + | .uri_encoded_bucket
|
12887 + | .as_ref()
|
12888 + | .map(|s| s.clone())
|
12889 + | .expect("Guaranteed to have a value by earlier checks.");
|
12890 + | ::std::result::Result::Ok(
|
12891 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
12892 + | .url({
|
12893 + | let mut out = String::new();
|
12894 + | out.push_str("https://s3express-control");
|
12895 + | #[allow(clippy::needless_borrow)]
|
12896 + | out.push_str(&s3_e_fips.as_ref());
|
12897 + | #[allow(clippy::needless_borrow)]
|
12898 + | out.push_str(&s3_e_ds.as_ref());
|
12899 + | out.push('.');
|
12900 + | #[allow(clippy::needless_borrow)]
|
12901 + | out.push_str(&effective_std_region.as_ref());
|
12902 + | out.push('.');
|
12903 + | #[allow(clippy::needless_borrow)]
|
12904 + | out.push_str(&partition_result.dns_suffix());
|
12905 + | out.push('/');
|
12906 + | #[allow(clippy::needless_borrow)]
|
12907 + | out.push_str(&uri_encoded_bucket.as_ref());
|
12908 + | out
|
12909 + | })
|
12910 + | .property("backend", "S3Express".to_string())
|
12911 + | .property(
|
12912 + | "authSchemes",
|
12913 + | vec![::aws_smithy_types::Document::from({
|
12914 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
12915 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
12916 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
12917 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
12918 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
12919 + | out
|
12920 + | })],
|
12921 + | )
|
12922 + | .build(),
|
12923 + | )
|
12924 + | }
|
12925 + | Self::Result11 => {
|
12926 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
12927 + | let effective_std_region = context
|
12928 + | .effective_std_region
|
12929 + | .as_ref()
|
12930 + | .map(|s| s.clone())
|
12931 + | .expect("Guaranteed to have a value by earlier checks.");
|
12932 + | let partition_result = context
|
12933 + | .partition_result
|
12934 + | .as_ref()
|
12935 + | .map(|s| s.clone())
|
12936 + | .expect("Guaranteed to have a value by earlier checks.");
|
12937 + | let s3_e_ds = context
|
12938 + | .s3_e_ds
|
12939 + | .as_ref()
|
12940 + | .map(|s| s.clone())
|
12941 + | .expect("Guaranteed to have a value by earlier checks.");
|
12942 + | let s3_e_fips = context
|
12943 + | .s3_e_fips
|
12944 + | .as_ref()
|
12945 + | .map(|s| s.clone())
|
12946 + | .expect("Guaranteed to have a value by earlier checks.");
|
12947 + | let s3_e_auth = context
|
12948 + | .s3_e_auth
|
12949 + | .as_ref()
|
12950 + | .map(|s| s.clone())
|
12951 + | .expect("Guaranteed to have a value by earlier checks.");
|
12952 + | let s3express_availability_zone_id = context
|
12953 + | .s3express_availability_zone_id
|
12954 + | .as_ref()
|
12955 + | .map(|s| s.clone())
|
12956 + | .expect("Guaranteed to have a value by earlier checks.");
|
12957 + | ::std::result::Result::Ok(
|
12958 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
12959 + | .url({
|
12960 + | let mut out = String::new();
|
12961 + | out.push_str("https://");
|
12962 + | #[allow(clippy::needless_borrow)]
|
12963 + | out.push_str(&bucket.as_ref());
|
12964 + | out.push_str(".s3express");
|
12965 + | #[allow(clippy::needless_borrow)]
|
12966 + | out.push_str(&s3_e_fips.as_ref());
|
12967 + | out.push('-');
|
12968 + | #[allow(clippy::needless_borrow)]
|
12969 + | out.push_str(&s3express_availability_zone_id.as_ref());
|
12970 + | #[allow(clippy::needless_borrow)]
|
12971 + | out.push_str(&s3_e_ds.as_ref());
|
12972 + | out.push('.');
|
12973 + | #[allow(clippy::needless_borrow)]
|
12974 + | out.push_str(&effective_std_region.as_ref());
|
12975 + | out.push('.');
|
12976 + | #[allow(clippy::needless_borrow)]
|
12977 + | out.push_str(&partition_result.dns_suffix());
|
12978 + | out
|
12979 + | })
|
12980 + | .property("backend", "S3Express".to_string())
|
12981 + | .property(
|
12982 + | "authSchemes",
|
12983 + | vec![::aws_smithy_types::Document::from({
|
12984 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
12985 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
12986 + | out.insert("name".to_string(), s3_e_auth.to_owned().into());
|
12987 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
12988 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
12989 + | out
|
12990 + | })],
|
12991 + | )
|
12992 + | .build(),
|
12993 + | )
|
12994 + | }
|
12995 + | Self::Result12 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
12996 + | "Unrecognized S3Express bucket name format.".to_string(),
|
12997 + | )),
|
12998 + | Self::Result13 => {
|
12999 + | let effective_std_region = context
|
13000 + | .effective_std_region
|
13001 + | .as_ref()
|
13002 + | .map(|s| s.clone())
|
13003 + | .expect("Guaranteed to have a value by earlier checks.");
|
13004 + | let url = context
|
13005 + | .url
|
13006 + | .as_ref()
|
13007 + | .map(|s| s.clone())
|
13008 + | .expect("Guaranteed to have a value by earlier checks.");
|
13009 + | let s3_e_auth = context
|
13010 + | .s3_e_auth
|
13011 + | .as_ref()
|
13012 + | .map(|s| s.clone())
|
13013 + | .expect("Guaranteed to have a value by earlier checks.");
|
13014 + | ::std::result::Result::Ok(
|
13015 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13016 + | .url({
|
13017 + | let mut out = String::new();
|
13018 + | #[allow(clippy::needless_borrow)]
|
13019 + | out.push_str(&url.scheme());
|
13020 + | out.push_str("://");
|
13021 + | #[allow(clippy::needless_borrow)]
|
13022 + | out.push_str(&url.authority());
|
13023 + | #[allow(clippy::needless_borrow)]
|
13024 + | out.push_str(&url.path());
|
13025 + | out
|
13026 + | })
|
13027 + | .property("backend", "S3Express".to_string())
|
13028 + | .property(
|
13029 + | "authSchemes",
|
13030 + | vec![::aws_smithy_types::Document::from({
|
13031 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13032 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13033 + | out.insert("name".to_string(), s3_e_auth.to_owned().into());
|
13034 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
13035 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13036 + | out
|
13037 + | })],
|
13038 + | )
|
13039 + | .build(),
|
13040 + | )
|
13041 + | }
|
13042 + | Self::Result14 => {
|
13043 + | let effective_std_region = context
|
13044 + | .effective_std_region
|
13045 + | .as_ref()
|
13046 + | .map(|s| s.clone())
|
13047 + | .expect("Guaranteed to have a value by earlier checks.");
|
13048 + | let partition_result = context
|
13049 + | .partition_result
|
13050 + | .as_ref()
|
13051 + | .map(|s| s.clone())
|
13052 + | .expect("Guaranteed to have a value by earlier checks.");
|
13053 + | let s3_e_ds = context
|
13054 + | .s3_e_ds
|
13055 + | .as_ref()
|
13056 + | .map(|s| s.clone())
|
13057 + | .expect("Guaranteed to have a value by earlier checks.");
|
13058 + | let s3_e_fips = context
|
13059 + | .s3_e_fips
|
13060 + | .as_ref()
|
13061 + | .map(|s| s.clone())
|
13062 + | .expect("Guaranteed to have a value by earlier checks.");
|
13063 + | ::std::result::Result::Ok(
|
13064 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13065 + | .url({
|
13066 + | let mut out = String::new();
|
13067 + | out.push_str("https://s3express-control");
|
13068 + | #[allow(clippy::needless_borrow)]
|
13069 + | out.push_str(&s3_e_fips.as_ref());
|
13070 + | #[allow(clippy::needless_borrow)]
|
13071 + | out.push_str(&s3_e_ds.as_ref());
|
13072 + | out.push('.');
|
13073 + | #[allow(clippy::needless_borrow)]
|
13074 + | out.push_str(&effective_std_region.as_ref());
|
13075 + | out.push('.');
|
13076 + | #[allow(clippy::needless_borrow)]
|
13077 + | out.push_str(&partition_result.dns_suffix());
|
13078 + | out
|
13079 + | })
|
13080 + | .property("backend", "S3Express".to_string())
|
13081 + | .property(
|
13082 + | "authSchemes",
|
13083 + | vec![::aws_smithy_types::Document::from({
|
13084 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13085 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13086 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13087 + | out.insert("signingName".to_string(), "s3express".to_string().into());
|
13088 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13089 + | out
|
13090 + | })],
|
13091 + | )
|
13092 + | .build(),
|
13093 + | )
|
13094 + | }
|
13095 + | Self::Result15 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13096 + | "Expected a endpoint to be specified but no endpoint was found".to_string(),
|
13097 + | )),
|
13098 + | Self::Result16 => {
|
13099 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13100 + | let effective_std_region = context
|
13101 + | .effective_std_region
|
13102 + | .as_ref()
|
13103 + | .map(|s| s.clone())
|
13104 + | .expect("Guaranteed to have a value by earlier checks.");
|
13105 + | let url = context
|
13106 + | .url
|
13107 + | .as_ref()
|
13108 + | .map(|s| s.clone())
|
13109 + | .expect("Guaranteed to have a value by earlier checks.");
|
13110 + | ::std::result::Result::Ok(
|
13111 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13112 + | .url({
|
13113 + | let mut out = String::new();
|
13114 + | out.push_str("https://");
|
13115 + | #[allow(clippy::needless_borrow)]
|
13116 + | out.push_str(&bucket.as_ref());
|
13117 + | out.push_str(".ec2.");
|
13118 + | #[allow(clippy::needless_borrow)]
|
13119 + | out.push_str(&url.authority());
|
13120 + | out
|
13121 + | })
|
13122 + | .property(
|
13123 + | "authSchemes",
|
13124 + | vec![
|
13125 + | ::aws_smithy_types::Document::from({
|
13126 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13127 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13128 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
13129 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13130 + | out.insert(
|
13131 + | "signingRegionSet".to_string(),
|
13132 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
13133 + | );
|
13134 + | out
|
13135 + | }),
|
13136 + | ::aws_smithy_types::Document::from({
|
13137 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13138 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13139 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13140 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13141 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13142 + | out
|
13143 + | }),
|
13144 + | ],
|
13145 + | )
|
13146 + | .build(),
|
13147 + | )
|
13148 + | }
|
13149 + | Self::Result17 => {
|
13150 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13151 + | let effective_std_region = context
|
13152 + | .effective_std_region
|
13153 + | .as_ref()
|
13154 + | .map(|s| s.clone())
|
13155 + | .expect("Guaranteed to have a value by earlier checks.");
|
13156 + | let partition_result = context
|
13157 + | .partition_result
|
13158 + | .as_ref()
|
13159 + | .map(|s| s.clone())
|
13160 + | .expect("Guaranteed to have a value by earlier checks.");
|
13161 + | ::std::result::Result::Ok(
|
13162 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13163 + | .url({
|
13164 + | let mut out = String::new();
|
13165 + | out.push_str("https://");
|
13166 + | #[allow(clippy::needless_borrow)]
|
13167 + | out.push_str(&bucket.as_ref());
|
13168 + | out.push_str(".ec2.s3-outposts.");
|
13169 + | #[allow(clippy::needless_borrow)]
|
13170 + | out.push_str(&effective_std_region.as_ref());
|
13171 + | out.push('.');
|
13172 + | #[allow(clippy::needless_borrow)]
|
13173 + | out.push_str(&partition_result.dns_suffix());
|
13174 + | out
|
13175 + | })
|
13176 + | .property(
|
13177 + | "authSchemes",
|
13178 + | vec![
|
13179 + | ::aws_smithy_types::Document::from({
|
13180 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13181 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13182 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
13183 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13184 + | out.insert(
|
13185 + | "signingRegionSet".to_string(),
|
13186 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
13187 + | );
|
13188 + | out
|
13189 + | }),
|
13190 + | ::aws_smithy_types::Document::from({
|
13191 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13192 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13193 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13194 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13195 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13196 + | out
|
13197 + | }),
|
13198 + | ],
|
13199 + | )
|
13200 + | .build(),
|
13201 + | )
|
13202 + | }
|
13203 + | Self::Result18 => {
|
13204 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13205 + | let effective_std_region = context
|
13206 + | .effective_std_region
|
13207 + | .as_ref()
|
13208 + | .map(|s| s.clone())
|
13209 + | .expect("Guaranteed to have a value by earlier checks.");
|
13210 + | let url = context
|
13211 + | .url
|
13212 + | .as_ref()
|
13213 + | .map(|s| s.clone())
|
13214 + | .expect("Guaranteed to have a value by earlier checks.");
|
13215 + | let outpost_id_ssa_2 = context
|
13216 + | .outpost_id_ssa_2
|
13217 + | .as_ref()
|
13218 + | .map(|s| s.clone())
|
13219 + | .expect("Guaranteed to have a value by earlier checks.");
|
13220 + | ::std::result::Result::Ok(
|
13221 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13222 + | .url({
|
13223 + | let mut out = String::new();
|
13224 + | out.push_str("https://");
|
13225 + | #[allow(clippy::needless_borrow)]
|
13226 + | out.push_str(&bucket.as_ref());
|
13227 + | out.push_str(".op-");
|
13228 + | #[allow(clippy::needless_borrow)]
|
13229 + | out.push_str(&outpost_id_ssa_2.as_ref());
|
13230 + | out.push('.');
|
13231 + | #[allow(clippy::needless_borrow)]
|
13232 + | out.push_str(&url.authority());
|
13233 + | out
|
13234 + | })
|
13235 + | .property(
|
13236 + | "authSchemes",
|
13237 + | vec![
|
13238 + | ::aws_smithy_types::Document::from({
|
13239 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13240 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13241 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
13242 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13243 + | out.insert(
|
13244 + | "signingRegionSet".to_string(),
|
13245 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
13246 + | );
|
13247 + | out
|
13248 + | }),
|
13249 + | ::aws_smithy_types::Document::from({
|
13250 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13251 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13252 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13253 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13254 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13255 + | out
|
13256 + | }),
|
13257 + | ],
|
13258 + | )
|
13259 + | .build(),
|
13260 + | )
|
13261 + | }
|
13262 + | Self::Result19 => {
|
13263 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13264 + | let effective_std_region = context
|
13265 + | .effective_std_region
|
13266 + | .as_ref()
|
13267 + | .map(|s| s.clone())
|
13268 + | .expect("Guaranteed to have a value by earlier checks.");
|
13269 + | let partition_result = context
|
13270 + | .partition_result
|
13271 + | .as_ref()
|
13272 + | .map(|s| s.clone())
|
13273 + | .expect("Guaranteed to have a value by earlier checks.");
|
13274 + | let outpost_id_ssa_2 = context
|
13275 + | .outpost_id_ssa_2
|
13276 + | .as_ref()
|
13277 + | .map(|s| s.clone())
|
13278 + | .expect("Guaranteed to have a value by earlier checks.");
|
13279 + | ::std::result::Result::Ok(
|
13280 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13281 + | .url({
|
13282 + | let mut out = String::new();
|
13283 + | out.push_str("https://");
|
13284 + | #[allow(clippy::needless_borrow)]
|
13285 + | out.push_str(&bucket.as_ref());
|
13286 + | out.push_str(".op-");
|
13287 + | #[allow(clippy::needless_borrow)]
|
13288 + | out.push_str(&outpost_id_ssa_2.as_ref());
|
13289 + | out.push_str(".s3-outposts.");
|
13290 + | #[allow(clippy::needless_borrow)]
|
13291 + | out.push_str(&effective_std_region.as_ref());
|
13292 + | out.push('.');
|
13293 + | #[allow(clippy::needless_borrow)]
|
13294 + | out.push_str(&partition_result.dns_suffix());
|
13295 + | out
|
13296 + | })
|
13297 + | .property(
|
13298 + | "authSchemes",
|
13299 + | vec![
|
13300 + | ::aws_smithy_types::Document::from({
|
13301 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13302 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13303 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
13304 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13305 + | out.insert(
|
13306 + | "signingRegionSet".to_string(),
|
13307 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
13308 + | );
|
13309 + | out
|
13310 + | }),
|
13311 + | ::aws_smithy_types::Document::from({
|
13312 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13313 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13314 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13315 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
13316 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13317 + | out
|
13318 + | }),
|
13319 + | ],
|
13320 + | )
|
13321 + | .build(),
|
13322 + | )
|
13323 + | }
|
13324 + | Self::Result20 => {
|
13325 + | let hardware_type = context
|
13326 + | .hardware_type
|
13327 + | .as_ref()
|
13328 + | .map(|s| s.clone())
|
13329 + | .expect("Guaranteed to have a value by earlier checks.");
|
13330 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
13331 + | let mut out = String::new();
|
13332 + | out.push_str("Unrecognized hardware type: \"Expected hardware type o or e but got ");
|
13333 + | #[allow(clippy::needless_borrow)]
|
13334 + | out.push_str(&hardware_type.as_ref());
|
13335 + | out.push('"');
|
13336 + | out
|
13337 + | }))
|
13338 + | }
|
13339 + | Self::Result21 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13340 + | "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
|
13341 + | )),
|
13342 + | Self::Result22 => {
|
13343 + | let endpoint = params.endpoint.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13344 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
13345 + | let mut out = String::new();
|
13346 + | out.push_str("Custom endpoint `");
|
13347 + | #[allow(clippy::needless_borrow)]
|
13348 + | out.push_str(&endpoint.as_ref());
|
13349 + | out.push_str("` was not a valid URI");
|
13350 + | out
|
13351 + | }))
|
13352 + | }
|
13353 + | Self::Result23 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13354 + | "S3 Accelerate cannot be used in this region".to_string(),
|
13355 + | )),
|
13356 + | Self::Result24 => {
|
13357 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13358 + | let effective_std_region = context
|
13359 + | .effective_std_region
|
13360 + | .as_ref()
|
13361 + | .map(|s| s.clone())
|
13362 + | .expect("Guaranteed to have a value by earlier checks.");
|
13363 + | let partition_result = context
|
13364 + | .partition_result
|
13365 + | .as_ref()
|
13366 + | .map(|s| s.clone())
|
13367 + | .expect("Guaranteed to have a value by earlier checks.");
|
13368 + | ::std::result::Result::Ok(
|
13369 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13370 + | .url({
|
13371 + | let mut out = String::new();
|
13372 + | out.push_str("https://");
|
13373 + | #[allow(clippy::needless_borrow)]
|
13374 + | out.push_str(&bucket.as_ref());
|
13375 + | out.push_str(".s3-fips.dualstack.");
|
13376 + | #[allow(clippy::needless_borrow)]
|
13377 + | out.push_str(&effective_std_region.as_ref());
|
13378 + | out.push('.');
|
13379 + | #[allow(clippy::needless_borrow)]
|
13380 + | out.push_str(&partition_result.dns_suffix());
|
13381 + | out
|
13382 + | })
|
13383 + | .property(
|
13384 + | "authSchemes",
|
13385 + | vec![::aws_smithy_types::Document::from({
|
13386 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13387 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13388 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13389 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13390 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13391 + | out
|
13392 + | })],
|
13393 + | )
|
13394 + | .build(),
|
13395 + | )
|
13396 + | }
|
13397 + | Self::Result25 => {
|
13398 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13399 + | let effective_std_region = context
|
13400 + | .effective_std_region
|
13401 + | .as_ref()
|
13402 + | .map(|s| s.clone())
|
13403 + | .expect("Guaranteed to have a value by earlier checks.");
|
13404 + | let partition_result = context
|
13405 + | .partition_result
|
13406 + | .as_ref()
|
13407 + | .map(|s| s.clone())
|
13408 + | .expect("Guaranteed to have a value by earlier checks.");
|
13409 + | ::std::result::Result::Ok(
|
13410 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13411 + | .url({
|
13412 + | let mut out = String::new();
|
13413 + | out.push_str("https://");
|
13414 + | #[allow(clippy::needless_borrow)]
|
13415 + | out.push_str(&bucket.as_ref());
|
13416 + | out.push_str(".s3-fips.");
|
13417 + | #[allow(clippy::needless_borrow)]
|
13418 + | out.push_str(&effective_std_region.as_ref());
|
13419 + | out.push('.');
|
13420 + | #[allow(clippy::needless_borrow)]
|
13421 + | out.push_str(&partition_result.dns_suffix());
|
13422 + | out
|
13423 + | })
|
13424 + | .property(
|
13425 + | "authSchemes",
|
13426 + | vec![::aws_smithy_types::Document::from({
|
13427 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13428 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13429 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13430 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13431 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13432 + | out
|
13433 + | })],
|
13434 + | )
|
13435 + | .build(),
|
13436 + | )
|
13437 + | }
|
13438 + | Self::Result26 => {
|
13439 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13440 + | let effective_std_region = context
|
13441 + | .effective_std_region
|
13442 + | .as_ref()
|
13443 + | .map(|s| s.clone())
|
13444 + | .expect("Guaranteed to have a value by earlier checks.");
|
13445 + | let partition_result = context
|
13446 + | .partition_result
|
13447 + | .as_ref()
|
13448 + | .map(|s| s.clone())
|
13449 + | .expect("Guaranteed to have a value by earlier checks.");
|
13450 + | ::std::result::Result::Ok(
|
13451 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13452 + | .url({
|
13453 + | let mut out = String::new();
|
13454 + | out.push_str("https://");
|
13455 + | #[allow(clippy::needless_borrow)]
|
13456 + | out.push_str(&bucket.as_ref());
|
13457 + | out.push_str(".s3-accelerate.dualstack.");
|
13458 + | #[allow(clippy::needless_borrow)]
|
13459 + | out.push_str(&effective_std_region.as_ref());
|
13460 + | out.push('.');
|
13461 + | #[allow(clippy::needless_borrow)]
|
13462 + | out.push_str(&partition_result.dns_suffix());
|
13463 + | out
|
13464 + | })
|
13465 + | .property(
|
13466 + | "authSchemes",
|
13467 + | vec![::aws_smithy_types::Document::from({
|
13468 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13469 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13470 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13471 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13472 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13473 + | out
|
13474 + | })],
|
13475 + | )
|
13476 + | .build(),
|
13477 + | )
|
13478 + | }
|
13479 + | Self::Result27 => {
|
13480 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13481 + | let effective_std_region = context
|
13482 + | .effective_std_region
|
13483 + | .as_ref()
|
13484 + | .map(|s| s.clone())
|
13485 + | .expect("Guaranteed to have a value by earlier checks.");
|
13486 + | let partition_result = context
|
13487 + | .partition_result
|
13488 + | .as_ref()
|
13489 + | .map(|s| s.clone())
|
13490 + | .expect("Guaranteed to have a value by earlier checks.");
|
13491 + | ::std::result::Result::Ok(
|
13492 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13493 + | .url({
|
13494 + | let mut out = String::new();
|
13495 + | out.push_str("https://");
|
13496 + | #[allow(clippy::needless_borrow)]
|
13497 + | out.push_str(&bucket.as_ref());
|
13498 + | out.push_str(".s3-accelerate.dualstack.");
|
13499 + | #[allow(clippy::needless_borrow)]
|
13500 + | out.push_str(&partition_result.dns_suffix());
|
13501 + | out
|
13502 + | })
|
13503 + | .property(
|
13504 + | "authSchemes",
|
13505 + | vec![::aws_smithy_types::Document::from({
|
13506 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13507 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13508 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13509 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13510 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13511 + | out
|
13512 + | })],
|
13513 + | )
|
13514 + | .build(),
|
13515 + | )
|
13516 + | }
|
13517 + | Self::Result28 => {
|
13518 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13519 + | let effective_std_region = context
|
13520 + | .effective_std_region
|
13521 + | .as_ref()
|
13522 + | .map(|s| s.clone())
|
13523 + | .expect("Guaranteed to have a value by earlier checks.");
|
13524 + | let partition_result = context
|
13525 + | .partition_result
|
13526 + | .as_ref()
|
13527 + | .map(|s| s.clone())
|
13528 + | .expect("Guaranteed to have a value by earlier checks.");
|
13529 + | ::std::result::Result::Ok(
|
13530 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13531 + | .url({
|
13532 + | let mut out = String::new();
|
13533 + | out.push_str("https://");
|
13534 + | #[allow(clippy::needless_borrow)]
|
13535 + | out.push_str(&bucket.as_ref());
|
13536 + | out.push_str(".s3.dualstack.");
|
13537 + | #[allow(clippy::needless_borrow)]
|
13538 + | out.push_str(&effective_std_region.as_ref());
|
13539 + | out.push('.');
|
13540 + | #[allow(clippy::needless_borrow)]
|
13541 + | out.push_str(&partition_result.dns_suffix());
|
13542 + | out
|
13543 + | })
|
13544 + | .property(
|
13545 + | "authSchemes",
|
13546 + | vec![::aws_smithy_types::Document::from({
|
13547 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13548 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13549 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13550 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13551 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13552 + | out
|
13553 + | })],
|
13554 + | )
|
13555 + | .build(),
|
13556 + | )
|
13557 + | }
|
13558 + | Self::Result29 => {
|
13559 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13560 + | let effective_std_region = context
|
13561 + | .effective_std_region
|
13562 + | .as_ref()
|
13563 + | .map(|s| s.clone())
|
13564 + | .expect("Guaranteed to have a value by earlier checks.");
|
13565 + | let url = context
|
13566 + | .url
|
13567 + | .as_ref()
|
13568 + | .map(|s| s.clone())
|
13569 + | .expect("Guaranteed to have a value by earlier checks.");
|
13570 + | ::std::result::Result::Ok(
|
13571 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13572 + | .url({
|
13573 + | let mut out = String::new();
|
13574 + | #[allow(clippy::needless_borrow)]
|
13575 + | out.push_str(&url.scheme());
|
13576 + | out.push_str("://");
|
13577 + | #[allow(clippy::needless_borrow)]
|
13578 + | out.push_str(&url.authority());
|
13579 + | #[allow(clippy::needless_borrow)]
|
13580 + | out.push_str(&url.normalized_path());
|
13581 + | #[allow(clippy::needless_borrow)]
|
13582 + | out.push_str(&bucket.as_ref());
|
13583 + | out
|
13584 + | })
|
13585 + | .property(
|
13586 + | "authSchemes",
|
13587 + | vec![::aws_smithy_types::Document::from({
|
13588 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13589 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13590 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13591 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13592 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13593 + | out
|
13594 + | })],
|
13595 + | )
|
13596 + | .build(),
|
13597 + | )
|
13598 + | }
|
13599 + | Self::Result30 => {
|
13600 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13601 + | let effective_std_region = context
|
13602 + | .effective_std_region
|
13603 + | .as_ref()
|
13604 + | .map(|s| s.clone())
|
13605 + | .expect("Guaranteed to have a value by earlier checks.");
|
13606 + | let url = context
|
13607 + | .url
|
13608 + | .as_ref()
|
13609 + | .map(|s| s.clone())
|
13610 + | .expect("Guaranteed to have a value by earlier checks.");
|
13611 + | ::std::result::Result::Ok(
|
13612 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13613 + | .url({
|
13614 + | let mut out = String::new();
|
13615 + | #[allow(clippy::needless_borrow)]
|
13616 + | out.push_str(&url.scheme());
|
13617 + | out.push_str("://");
|
13618 + | #[allow(clippy::needless_borrow)]
|
13619 + | out.push_str(&bucket.as_ref());
|
13620 + | out.push('.');
|
13621 + | #[allow(clippy::needless_borrow)]
|
13622 + | out.push_str(&url.authority());
|
13623 + | #[allow(clippy::needless_borrow)]
|
13624 + | out.push_str(&url.path());
|
13625 + | out
|
13626 + | })
|
13627 + | .property(
|
13628 + | "authSchemes",
|
13629 + | vec![::aws_smithy_types::Document::from({
|
13630 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13631 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13632 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13633 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13634 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13635 + | out
|
13636 + | })],
|
13637 + | )
|
13638 + | .build(),
|
13639 + | )
|
13640 + | }
|
13641 + | Self::Result31 => {
|
13642 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13643 + | let effective_std_region = context
|
13644 + | .effective_std_region
|
13645 + | .as_ref()
|
13646 + | .map(|s| s.clone())
|
13647 + | .expect("Guaranteed to have a value by earlier checks.");
|
13648 + | let partition_result = context
|
13649 + | .partition_result
|
13650 + | .as_ref()
|
13651 + | .map(|s| s.clone())
|
13652 + | .expect("Guaranteed to have a value by earlier checks.");
|
13653 + | ::std::result::Result::Ok(
|
13654 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13655 + | .url({
|
13656 + | let mut out = String::new();
|
13657 + | out.push_str("https://");
|
13658 + | #[allow(clippy::needless_borrow)]
|
13659 + | out.push_str(&bucket.as_ref());
|
13660 + | out.push_str(".s3-accelerate.");
|
13661 + | #[allow(clippy::needless_borrow)]
|
13662 + | out.push_str(&partition_result.dns_suffix());
|
13663 + | out
|
13664 + | })
|
13665 + | .property(
|
13666 + | "authSchemes",
|
13667 + | vec![::aws_smithy_types::Document::from({
|
13668 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13669 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13670 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13671 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13672 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13673 + | out
|
13674 + | })],
|
13675 + | )
|
13676 + | .build(),
|
13677 + | )
|
13678 + | }
|
13679 + | Self::Result32 => {
|
13680 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13681 + | let effective_std_region = context
|
13682 + | .effective_std_region
|
13683 + | .as_ref()
|
13684 + | .map(|s| s.clone())
|
13685 + | .expect("Guaranteed to have a value by earlier checks.");
|
13686 + | let partition_result = context
|
13687 + | .partition_result
|
13688 + | .as_ref()
|
13689 + | .map(|s| s.clone())
|
13690 + | .expect("Guaranteed to have a value by earlier checks.");
|
13691 + | ::std::result::Result::Ok(
|
13692 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13693 + | .url({
|
13694 + | let mut out = String::new();
|
13695 + | out.push_str("https://");
|
13696 + | #[allow(clippy::needless_borrow)]
|
13697 + | out.push_str(&bucket.as_ref());
|
13698 + | out.push_str(".s3.");
|
13699 + | #[allow(clippy::needless_borrow)]
|
13700 + | out.push_str(&partition_result.dns_suffix());
|
13701 + | out
|
13702 + | })
|
13703 + | .property(
|
13704 + | "authSchemes",
|
13705 + | vec![::aws_smithy_types::Document::from({
|
13706 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13707 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13708 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13709 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13710 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13711 + | out
|
13712 + | })],
|
13713 + | )
|
13714 + | .build(),
|
13715 + | )
|
13716 + | }
|
13717 + | Self::Result33 => {
|
13718 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13719 + | let effective_std_region = context
|
13720 + | .effective_std_region
|
13721 + | .as_ref()
|
13722 + | .map(|s| s.clone())
|
13723 + | .expect("Guaranteed to have a value by earlier checks.");
|
13724 + | let partition_result = context
|
13725 + | .partition_result
|
13726 + | .as_ref()
|
13727 + | .map(|s| s.clone())
|
13728 + | .expect("Guaranteed to have a value by earlier checks.");
|
13729 + | ::std::result::Result::Ok(
|
13730 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13731 + | .url({
|
13732 + | let mut out = String::new();
|
13733 + | out.push_str("https://");
|
13734 + | #[allow(clippy::needless_borrow)]
|
13735 + | out.push_str(&bucket.as_ref());
|
13736 + | out.push_str(".s3.");
|
13737 + | #[allow(clippy::needless_borrow)]
|
13738 + | out.push_str(&effective_std_region.as_ref());
|
13739 + | out.push('.');
|
13740 + | #[allow(clippy::needless_borrow)]
|
13741 + | out.push_str(&partition_result.dns_suffix());
|
13742 + | out
|
13743 + | })
|
13744 + | .property(
|
13745 + | "authSchemes",
|
13746 + | vec![::aws_smithy_types::Document::from({
|
13747 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13748 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13749 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13750 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
13751 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
13752 + | out
|
13753 + | })],
|
13754 + | )
|
13755 + | .build(),
|
13756 + | )
|
13757 + | }
|
13758 + | Self::Result34 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13759 + | "Invalid region: region was not a valid DNS name.".to_string(),
|
13760 + | )),
|
13761 + | Self::Result35 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13762 + | "S3 Object Lambda does not support Dual-stack".to_string(),
|
13763 + | )),
|
13764 + | Self::Result36 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13765 + | "S3 Object Lambda does not support S3 Accelerate".to_string(),
|
13766 + | )),
|
13767 + | Self::Result37 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13768 + | "Access points are not supported for this operation".to_string(),
|
13769 + | )),
|
13770 + | Self::Result38 => {
|
13771 + | let region = params.region.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13772 + | let bucket_arn = context
|
13773 + | .bucket_arn
|
13774 + | .as_ref()
|
13775 + | .map(|s| s.clone())
|
13776 + | .expect("Guaranteed to have a value by earlier checks.");
|
13777 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
13778 + | let mut out = String::new();
|
13779 + | out.push_str("Invalid configuration: region from ARN `");
|
13780 + | #[allow(clippy::needless_borrow)]
|
13781 + | out.push_str(&bucket_arn.region());
|
13782 + | out.push_str("` does not match client region `");
|
13783 + | #[allow(clippy::needless_borrow)]
|
13784 + | out.push_str(®ion.as_ref());
|
13785 + | out.push_str("` and UseArnRegion is `false`");
|
13786 + | out
|
13787 + | }))
|
13788 + | }
|
13789 + | Self::Result39 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
13790 + | "Invalid ARN: Missing account id".to_string(),
|
13791 + | )),
|
13792 + | Self::Result40 => {
|
13793 + | let url = context
|
13794 + | .url
|
13795 + | .as_ref()
|
13796 + | .map(|s| s.clone())
|
13797 + | .expect("Guaranteed to have a value by earlier checks.");
|
13798 + | let bucket_arn = context
|
13799 + | .bucket_arn
|
13800 + | .as_ref()
|
13801 + | .map(|s| s.clone())
|
13802 + | .expect("Guaranteed to have a value by earlier checks.");
|
13803 + | let effective_arn_region = context
|
13804 + | .effective_arn_region
|
13805 + | .as_ref()
|
13806 + | .map(|s| s.clone())
|
13807 + | .expect("Guaranteed to have a value by earlier checks.");
|
13808 + | let access_point_name_ssa_1 = context
|
13809 + | .access_point_name_ssa_1
|
13810 + | .as_ref()
|
13811 + | .map(|s| s.clone())
|
13812 + | .expect("Guaranteed to have a value by earlier checks.");
|
13813 + | ::std::result::Result::Ok(
|
13814 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13815 + | .url({
|
13816 + | let mut out = String::new();
|
13817 + | #[allow(clippy::needless_borrow)]
|
13818 + | out.push_str(&url.scheme());
|
13819 + | out.push_str("://");
|
13820 + | #[allow(clippy::needless_borrow)]
|
13821 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
13822 + | out.push('-');
|
13823 + | #[allow(clippy::needless_borrow)]
|
13824 + | out.push_str(&bucket_arn.account_id());
|
13825 + | out.push('.');
|
13826 + | #[allow(clippy::needless_borrow)]
|
13827 + | out.push_str(&url.authority());
|
13828 + | #[allow(clippy::needless_borrow)]
|
13829 + | out.push_str(&url.path());
|
13830 + | out
|
13831 + | })
|
13832 + | .property(
|
13833 + | "authSchemes",
|
13834 + | vec![::aws_smithy_types::Document::from({
|
13835 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13836 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13837 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13838 + | out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
|
13839 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
13840 + | out
|
13841 + | })],
|
13842 + | )
|
13843 + | .build(),
|
13844 + | )
|
13845 + | }
|
13846 + | Self::Result41 => {
|
13847 + | let bucket_arn = context
|
13848 + | .bucket_arn
|
13849 + | .as_ref()
|
13850 + | .map(|s| s.clone())
|
13851 + | .expect("Guaranteed to have a value by earlier checks.");
|
13852 + | let effective_arn_region = context
|
13853 + | .effective_arn_region
|
13854 + | .as_ref()
|
13855 + | .map(|s| s.clone())
|
13856 + | .expect("Guaranteed to have a value by earlier checks.");
|
13857 + | let access_point_name_ssa_1 = context
|
13858 + | .access_point_name_ssa_1
|
13859 + | .as_ref()
|
13860 + | .map(|s| s.clone())
|
13861 + | .expect("Guaranteed to have a value by earlier checks.");
|
13862 + | let bucket_partition = context
|
13863 + | .bucket_partition
|
13864 + | .as_ref()
|
13865 + | .map(|s| s.clone())
|
13866 + | .expect("Guaranteed to have a value by earlier checks.");
|
13867 + | ::std::result::Result::Ok(
|
13868 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13869 + | .url({
|
13870 + | let mut out = String::new();
|
13871 + | out.push_str("https://");
|
13872 + | #[allow(clippy::needless_borrow)]
|
13873 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
13874 + | out.push('-');
|
13875 + | #[allow(clippy::needless_borrow)]
|
13876 + | out.push_str(&bucket_arn.account_id());
|
13877 + | out.push_str(".s3-object-lambda-fips.");
|
13878 + | #[allow(clippy::needless_borrow)]
|
13879 + | out.push_str(&effective_arn_region.as_ref());
|
13880 + | out.push('.');
|
13881 + | #[allow(clippy::needless_borrow)]
|
13882 + | out.push_str(&bucket_partition.dns_suffix());
|
13883 + | out
|
13884 + | })
|
13885 + | .property(
|
13886 + | "authSchemes",
|
13887 + | vec![::aws_smithy_types::Document::from({
|
13888 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13889 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13890 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13891 + | out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
|
13892 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
13893 + | out
|
13894 + | })],
|
13895 + | )
|
13896 + | .build(),
|
13897 + | )
|
13898 + | }
|
13899 + | Self::Result42 => {
|
13900 + | let bucket_arn = context
|
13901 + | .bucket_arn
|
13902 + | .as_ref()
|
13903 + | .map(|s| s.clone())
|
13904 + | .expect("Guaranteed to have a value by earlier checks.");
|
13905 + | let effective_arn_region = context
|
13906 + | .effective_arn_region
|
13907 + | .as_ref()
|
13908 + | .map(|s| s.clone())
|
13909 + | .expect("Guaranteed to have a value by earlier checks.");
|
13910 + | let access_point_name_ssa_1 = context
|
13911 + | .access_point_name_ssa_1
|
13912 + | .as_ref()
|
13913 + | .map(|s| s.clone())
|
13914 + | .expect("Guaranteed to have a value by earlier checks.");
|
13915 + | let bucket_partition = context
|
13916 + | .bucket_partition
|
13917 + | .as_ref()
|
13918 + | .map(|s| s.clone())
|
13919 + | .expect("Guaranteed to have a value by earlier checks.");
|
13920 + | ::std::result::Result::Ok(
|
13921 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
13922 + | .url({
|
13923 + | let mut out = String::new();
|
13924 + | out.push_str("https://");
|
13925 + | #[allow(clippy::needless_borrow)]
|
13926 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
13927 + | out.push('-');
|
13928 + | #[allow(clippy::needless_borrow)]
|
13929 + | out.push_str(&bucket_arn.account_id());
|
13930 + | out.push_str(".s3-object-lambda.");
|
13931 + | #[allow(clippy::needless_borrow)]
|
13932 + | out.push_str(&effective_arn_region.as_ref());
|
13933 + | out.push('.');
|
13934 + | #[allow(clippy::needless_borrow)]
|
13935 + | out.push_str(&bucket_partition.dns_suffix());
|
13936 + | out
|
13937 + | })
|
13938 + | .property(
|
13939 + | "authSchemes",
|
13940 + | vec![::aws_smithy_types::Document::from({
|
13941 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
13942 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
13943 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
13944 + | out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
|
13945 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
13946 + | out
|
13947 + | })],
|
13948 + | )
|
13949 + | .build(),
|
13950 + | )
|
13951 + | }
|
13952 + | Self::Result43 => {
|
13953 + | let access_point_name_ssa_1 = context
|
13954 + | .access_point_name_ssa_1
|
13955 + | .as_ref()
|
13956 + | .map(|s| s.clone())
|
13957 + | .expect("Guaranteed to have a value by earlier checks.");
|
13958 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
13959 + | let mut out = String::new();
|
13960 + | out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
|
13961 + | #[allow(clippy::needless_borrow)]
|
13962 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
13963 + | out.push('`');
|
13964 + | out
|
13965 + | }))
|
13966 + | }
|
13967 + | Self::Result44 => {
|
13968 + | let bucket_arn = context
|
13969 + | .bucket_arn
|
13970 + | .as_ref()
|
13971 + | .map(|s| s.clone())
|
13972 + | .expect("Guaranteed to have a value by earlier checks.");
|
13973 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
13974 + | let mut out = String::new();
|
13975 + | out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
|
13976 + | #[allow(clippy::needless_borrow)]
|
13977 + | out.push_str(&bucket_arn.account_id());
|
13978 + | out.push('`');
|
13979 + | out
|
13980 + | }))
|
13981 + | }
|
13982 + | Self::Result45 => {
|
13983 + | let bucket_arn = context
|
13984 + | .bucket_arn
|
13985 + | .as_ref()
|
13986 + | .map(|s| s.clone())
|
13987 + | .expect("Guaranteed to have a value by earlier checks.");
|
13988 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
13989 + | let mut out = String::new();
|
13990 + | out.push_str("Invalid region in ARN: `");
|
13991 + | #[allow(clippy::needless_borrow)]
|
13992 + | out.push_str(&bucket_arn.region());
|
13993 + | out.push_str("` (invalid DNS name)");
|
13994 + | out
|
13995 + | }))
|
13996 + | }
|
13997 + | Self::Result46 => {
|
13998 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
13999 + | let partition_result = context
|
14000 + | .partition_result
|
14001 + | .as_ref()
|
14002 + | .map(|s| s.clone())
|
14003 + | .expect("Guaranteed to have a value by earlier checks.");
|
14004 + | let bucket_partition = context
|
14005 + | .bucket_partition
|
14006 + | .as_ref()
|
14007 + | .map(|s| s.clone())
|
14008 + | .expect("Guaranteed to have a value by earlier checks.");
|
14009 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14010 + | let mut out = String::new();
|
14011 + | out.push_str("Client was configured for partition `");
|
14012 + | #[allow(clippy::needless_borrow)]
|
14013 + | out.push_str(&partition_result.name());
|
14014 + | out.push_str("` but ARN (`");
|
14015 + | #[allow(clippy::needless_borrow)]
|
14016 + | out.push_str(&bucket.as_ref());
|
14017 + | out.push_str("`) has `");
|
14018 + | #[allow(clippy::needless_borrow)]
|
14019 + | out.push_str(&bucket_partition.name());
|
14020 + | out.push('`');
|
14021 + | out
|
14022 + | }))
|
14023 + | }
|
14024 + | Self::Result47 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14025 + | "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.".to_string(),
|
14026 + | )),
|
14027 + | Self::Result48 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14028 + | "Invalid ARN: bucket ARN is missing a region".to_string(),
|
14029 + | )),
|
14030 + | Self::Result49 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14031 + | "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided".to_string(),
|
14032 + | )),
|
14033 + | Self::Result50 => {
|
14034 + | let arn_type = context
|
14035 + | .arn_type
|
14036 + | .as_ref()
|
14037 + | .map(|s| s.clone())
|
14038 + | .expect("Guaranteed to have a value by earlier checks.");
|
14039 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14040 + | let mut out = String::new();
|
14041 + | out.push_str("Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `");
|
14042 + | #[allow(clippy::needless_borrow)]
|
14043 + | out.push_str(&arn_type.as_ref());
|
14044 + | out.push('`');
|
14045 + | out
|
14046 + | }))
|
14047 + | }
|
14048 + | Self::Result51 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14049 + | "Access Points do not support S3 Accelerate".to_string(),
|
14050 + | )),
|
14051 + | Self::Result52 => {
|
14052 + | let bucket_arn = context
|
14053 + | .bucket_arn
|
14054 + | .as_ref()
|
14055 + | .map(|s| s.clone())
|
14056 + | .expect("Guaranteed to have a value by earlier checks.");
|
14057 + | let effective_arn_region = context
|
14058 + | .effective_arn_region
|
14059 + | .as_ref()
|
14060 + | .map(|s| s.clone())
|
14061 + | .expect("Guaranteed to have a value by earlier checks.");
|
14062 + | let access_point_name_ssa_1 = context
|
14063 + | .access_point_name_ssa_1
|
14064 + | .as_ref()
|
14065 + | .map(|s| s.clone())
|
14066 + | .expect("Guaranteed to have a value by earlier checks.");
|
14067 + | let bucket_partition = context
|
14068 + | .bucket_partition
|
14069 + | .as_ref()
|
14070 + | .map(|s| s.clone())
|
14071 + | .expect("Guaranteed to have a value by earlier checks.");
|
14072 + | ::std::result::Result::Ok(
|
14073 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14074 + | .url({
|
14075 + | let mut out = String::new();
|
14076 + | out.push_str("https://");
|
14077 + | #[allow(clippy::needless_borrow)]
|
14078 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
14079 + | out.push('-');
|
14080 + | #[allow(clippy::needless_borrow)]
|
14081 + | out.push_str(&bucket_arn.account_id());
|
14082 + | out.push_str(".s3-accesspoint-fips.dualstack.");
|
14083 + | #[allow(clippy::needless_borrow)]
|
14084 + | out.push_str(&effective_arn_region.as_ref());
|
14085 + | out.push('.');
|
14086 + | #[allow(clippy::needless_borrow)]
|
14087 + | out.push_str(&bucket_partition.dns_suffix());
|
14088 + | out
|
14089 + | })
|
14090 + | .property(
|
14091 + | "authSchemes",
|
14092 + | vec![::aws_smithy_types::Document::from({
|
14093 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14094 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14095 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14096 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14097 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14098 + | out
|
14099 + | })],
|
14100 + | )
|
14101 + | .build(),
|
14102 + | )
|
14103 + | }
|
14104 + | Self::Result53 => {
|
14105 + | let bucket_arn = context
|
14106 + | .bucket_arn
|
14107 + | .as_ref()
|
14108 + | .map(|s| s.clone())
|
14109 + | .expect("Guaranteed to have a value by earlier checks.");
|
14110 + | let effective_arn_region = context
|
14111 + | .effective_arn_region
|
14112 + | .as_ref()
|
14113 + | .map(|s| s.clone())
|
14114 + | .expect("Guaranteed to have a value by earlier checks.");
|
14115 + | let access_point_name_ssa_1 = context
|
14116 + | .access_point_name_ssa_1
|
14117 + | .as_ref()
|
14118 + | .map(|s| s.clone())
|
14119 + | .expect("Guaranteed to have a value by earlier checks.");
|
14120 + | let bucket_partition = context
|
14121 + | .bucket_partition
|
14122 + | .as_ref()
|
14123 + | .map(|s| s.clone())
|
14124 + | .expect("Guaranteed to have a value by earlier checks.");
|
14125 + | ::std::result::Result::Ok(
|
14126 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14127 + | .url({
|
14128 + | let mut out = String::new();
|
14129 + | out.push_str("https://");
|
14130 + | #[allow(clippy::needless_borrow)]
|
14131 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
14132 + | out.push('-');
|
14133 + | #[allow(clippy::needless_borrow)]
|
14134 + | out.push_str(&bucket_arn.account_id());
|
14135 + | out.push_str(".s3-accesspoint-fips.");
|
14136 + | #[allow(clippy::needless_borrow)]
|
14137 + | out.push_str(&effective_arn_region.as_ref());
|
14138 + | out.push('.');
|
14139 + | #[allow(clippy::needless_borrow)]
|
14140 + | out.push_str(&bucket_partition.dns_suffix());
|
14141 + | out
|
14142 + | })
|
14143 + | .property(
|
14144 + | "authSchemes",
|
14145 + | vec![::aws_smithy_types::Document::from({
|
14146 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14147 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14148 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14149 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14150 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14151 + | out
|
14152 + | })],
|
14153 + | )
|
14154 + | .build(),
|
14155 + | )
|
14156 + | }
|
14157 + | Self::Result54 => {
|
14158 + | let bucket_arn = context
|
14159 + | .bucket_arn
|
14160 + | .as_ref()
|
14161 + | .map(|s| s.clone())
|
14162 + | .expect("Guaranteed to have a value by earlier checks.");
|
14163 + | let effective_arn_region = context
|
14164 + | .effective_arn_region
|
14165 + | .as_ref()
|
14166 + | .map(|s| s.clone())
|
14167 + | .expect("Guaranteed to have a value by earlier checks.");
|
14168 + | let access_point_name_ssa_1 = context
|
14169 + | .access_point_name_ssa_1
|
14170 + | .as_ref()
|
14171 + | .map(|s| s.clone())
|
14172 + | .expect("Guaranteed to have a value by earlier checks.");
|
14173 + | let bucket_partition = context
|
14174 + | .bucket_partition
|
14175 + | .as_ref()
|
14176 + | .map(|s| s.clone())
|
14177 + | .expect("Guaranteed to have a value by earlier checks.");
|
14178 + | ::std::result::Result::Ok(
|
14179 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14180 + | .url({
|
14181 + | let mut out = String::new();
|
14182 + | out.push_str("https://");
|
14183 + | #[allow(clippy::needless_borrow)]
|
14184 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
14185 + | out.push('-');
|
14186 + | #[allow(clippy::needless_borrow)]
|
14187 + | out.push_str(&bucket_arn.account_id());
|
14188 + | out.push_str(".s3-accesspoint.dualstack.");
|
14189 + | #[allow(clippy::needless_borrow)]
|
14190 + | out.push_str(&effective_arn_region.as_ref());
|
14191 + | out.push('.');
|
14192 + | #[allow(clippy::needless_borrow)]
|
14193 + | out.push_str(&bucket_partition.dns_suffix());
|
14194 + | out
|
14195 + | })
|
14196 + | .property(
|
14197 + | "authSchemes",
|
14198 + | vec![::aws_smithy_types::Document::from({
|
14199 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14200 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14201 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14202 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14203 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14204 + | out
|
14205 + | })],
|
14206 + | )
|
14207 + | .build(),
|
14208 + | )
|
14209 + | }
|
14210 + | Self::Result55 => {
|
14211 + | let url = context
|
14212 + | .url
|
14213 + | .as_ref()
|
14214 + | .map(|s| s.clone())
|
14215 + | .expect("Guaranteed to have a value by earlier checks.");
|
14216 + | let bucket_arn = context
|
14217 + | .bucket_arn
|
14218 + | .as_ref()
|
14219 + | .map(|s| s.clone())
|
14220 + | .expect("Guaranteed to have a value by earlier checks.");
|
14221 + | let effective_arn_region = context
|
14222 + | .effective_arn_region
|
14223 + | .as_ref()
|
14224 + | .map(|s| s.clone())
|
14225 + | .expect("Guaranteed to have a value by earlier checks.");
|
14226 + | let access_point_name_ssa_1 = context
|
14227 + | .access_point_name_ssa_1
|
14228 + | .as_ref()
|
14229 + | .map(|s| s.clone())
|
14230 + | .expect("Guaranteed to have a value by earlier checks.");
|
14231 + | ::std::result::Result::Ok(
|
14232 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14233 + | .url({
|
14234 + | let mut out = String::new();
|
14235 + | #[allow(clippy::needless_borrow)]
|
14236 + | out.push_str(&url.scheme());
|
14237 + | out.push_str("://");
|
14238 + | #[allow(clippy::needless_borrow)]
|
14239 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
14240 + | out.push('-');
|
14241 + | #[allow(clippy::needless_borrow)]
|
14242 + | out.push_str(&bucket_arn.account_id());
|
14243 + | out.push('.');
|
14244 + | #[allow(clippy::needless_borrow)]
|
14245 + | out.push_str(&url.authority());
|
14246 + | #[allow(clippy::needless_borrow)]
|
14247 + | out.push_str(&url.path());
|
14248 + | out
|
14249 + | })
|
14250 + | .property(
|
14251 + | "authSchemes",
|
14252 + | vec![::aws_smithy_types::Document::from({
|
14253 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14254 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14255 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14256 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14257 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14258 + | out
|
14259 + | })],
|
14260 + | )
|
14261 + | .build(),
|
14262 + | )
|
14263 + | }
|
14264 + | Self::Result56 => {
|
14265 + | let bucket_arn = context
|
14266 + | .bucket_arn
|
14267 + | .as_ref()
|
14268 + | .map(|s| s.clone())
|
14269 + | .expect("Guaranteed to have a value by earlier checks.");
|
14270 + | let effective_arn_region = context
|
14271 + | .effective_arn_region
|
14272 + | .as_ref()
|
14273 + | .map(|s| s.clone())
|
14274 + | .expect("Guaranteed to have a value by earlier checks.");
|
14275 + | let access_point_name_ssa_1 = context
|
14276 + | .access_point_name_ssa_1
|
14277 + | .as_ref()
|
14278 + | .map(|s| s.clone())
|
14279 + | .expect("Guaranteed to have a value by earlier checks.");
|
14280 + | let bucket_partition = context
|
14281 + | .bucket_partition
|
14282 + | .as_ref()
|
14283 + | .map(|s| s.clone())
|
14284 + | .expect("Guaranteed to have a value by earlier checks.");
|
14285 + | ::std::result::Result::Ok(
|
14286 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14287 + | .url({
|
14288 + | let mut out = String::new();
|
14289 + | out.push_str("https://");
|
14290 + | #[allow(clippy::needless_borrow)]
|
14291 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
14292 + | out.push('-');
|
14293 + | #[allow(clippy::needless_borrow)]
|
14294 + | out.push_str(&bucket_arn.account_id());
|
14295 + | out.push_str(".s3-accesspoint.");
|
14296 + | #[allow(clippy::needless_borrow)]
|
14297 + | out.push_str(&effective_arn_region.as_ref());
|
14298 + | out.push('.');
|
14299 + | #[allow(clippy::needless_borrow)]
|
14300 + | out.push_str(&bucket_partition.dns_suffix());
|
14301 + | out
|
14302 + | })
|
14303 + | .property(
|
14304 + | "authSchemes",
|
14305 + | vec![::aws_smithy_types::Document::from({
|
14306 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14307 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14308 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14309 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14310 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14311 + | out
|
14312 + | })],
|
14313 + | )
|
14314 + | .build(),
|
14315 + | )
|
14316 + | }
|
14317 + | Self::Result57 => {
|
14318 + | let bucket_arn = context
|
14319 + | .bucket_arn
|
14320 + | .as_ref()
|
14321 + | .map(|s| s.clone())
|
14322 + | .expect("Guaranteed to have a value by earlier checks.");
|
14323 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14324 + | let mut out = String::new();
|
14325 + | out.push_str("Invalid ARN: The ARN was not for the S3 service, found: ");
|
14326 + | #[allow(clippy::needless_borrow)]
|
14327 + | out.push_str(&bucket_arn.service());
|
14328 + | out
|
14329 + | }))
|
14330 + | }
|
14331 + | Self::Result58 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14332 + | "S3 MRAP does not support dual-stack".to_string(),
|
14333 + | )),
|
14334 + | Self::Result59 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14335 + | "S3 MRAP does not support FIPS".to_string(),
|
14336 + | )),
|
14337 + | Self::Result60 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14338 + | "S3 MRAP does not support S3 Accelerate".to_string(),
|
14339 + | )),
|
14340 + | Self::Result61 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14341 + | "Invalid configuration: Multi-Region Access Point ARNs are disabled.".to_string(),
|
14342 + | )),
|
14343 + | Self::Result62 => {
|
14344 + | let partition_result = context
|
14345 + | .partition_result
|
14346 + | .as_ref()
|
14347 + | .map(|s| s.clone())
|
14348 + | .expect("Guaranteed to have a value by earlier checks.");
|
14349 + | let access_point_name_ssa_1 = context
|
14350 + | .access_point_name_ssa_1
|
14351 + | .as_ref()
|
14352 + | .map(|s| s.clone())
|
14353 + | .expect("Guaranteed to have a value by earlier checks.");
|
14354 + | ::std::result::Result::Ok(
|
14355 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14356 + | .url({
|
14357 + | let mut out = String::new();
|
14358 + | out.push_str("https://");
|
14359 + | #[allow(clippy::needless_borrow)]
|
14360 + | out.push_str(&access_point_name_ssa_1.as_ref());
|
14361 + | out.push_str(".accesspoint.s3-global.");
|
14362 + | #[allow(clippy::needless_borrow)]
|
14363 + | out.push_str(&partition_result.dns_suffix());
|
14364 + | out
|
14365 + | })
|
14366 + | .property(
|
14367 + | "authSchemes",
|
14368 + | vec![::aws_smithy_types::Document::from({
|
14369 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14370 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14371 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
14372 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14373 + | out.insert(
|
14374 + | "signingRegionSet".to_string(),
|
14375 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
14376 + | );
|
14377 + | out
|
14378 + | })],
|
14379 + | )
|
14380 + | .build(),
|
14381 + | )
|
14382 + | }
|
14383 + | Self::Result63 => {
|
14384 + | let partition_result = context
|
14385 + | .partition_result
|
14386 + | .as_ref()
|
14387 + | .map(|s| s.clone())
|
14388 + | .expect("Guaranteed to have a value by earlier checks.");
|
14389 + | let bucket_arn = context
|
14390 + | .bucket_arn
|
14391 + | .as_ref()
|
14392 + | .map(|s| s.clone())
|
14393 + | .expect("Guaranteed to have a value by earlier checks.");
|
14394 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14395 + | let mut out = String::new();
|
14396 + | out.push_str("Client was configured for partition `");
|
14397 + | #[allow(clippy::needless_borrow)]
|
14398 + | out.push_str(&partition_result.name());
|
14399 + | out.push_str("` but bucket referred to partition `");
|
14400 + | #[allow(clippy::needless_borrow)]
|
14401 + | out.push_str(&bucket_arn.partition());
|
14402 + | out.push('`');
|
14403 + | out
|
14404 + | }))
|
14405 + | }
|
14406 + | Self::Result64 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14407 + | "Invalid Access Point Name".to_string(),
|
14408 + | )),
|
14409 + | Self::Result65 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14410 + | "S3 Outposts does not support Dual-stack".to_string(),
|
14411 + | )),
|
14412 + | Self::Result66 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14413 + | "S3 Outposts does not support FIPS".to_string(),
|
14414 + | )),
|
14415 + | Self::Result67 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14416 + | "S3 Outposts does not support S3 Accelerate".to_string(),
|
14417 + | )),
|
14418 + | Self::Result68 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14419 + | "Invalid Arn: Outpost Access Point ARN contains sub resources".to_string(),
|
14420 + | )),
|
14421 + | Self::Result69 => {
|
14422 + | let url = context
|
14423 + | .url
|
14424 + | .as_ref()
|
14425 + | .map(|s| s.clone())
|
14426 + | .expect("Guaranteed to have a value by earlier checks.");
|
14427 + | let bucket_arn = context
|
14428 + | .bucket_arn
|
14429 + | .as_ref()
|
14430 + | .map(|s| s.clone())
|
14431 + | .expect("Guaranteed to have a value by earlier checks.");
|
14432 + | let effective_arn_region = context
|
14433 + | .effective_arn_region
|
14434 + | .as_ref()
|
14435 + | .map(|s| s.clone())
|
14436 + | .expect("Guaranteed to have a value by earlier checks.");
|
14437 + | let outpost_id_ssa_1 = context
|
14438 + | .outpost_id_ssa_1
|
14439 + | .as_ref()
|
14440 + | .map(|s| s.clone())
|
14441 + | .expect("Guaranteed to have a value by earlier checks.");
|
14442 + | let access_point_name_ssa_2 = context
|
14443 + | .access_point_name_ssa_2
|
14444 + | .as_ref()
|
14445 + | .map(|s| s.clone())
|
14446 + | .expect("Guaranteed to have a value by earlier checks.");
|
14447 + | ::std::result::Result::Ok(
|
14448 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14449 + | .url({
|
14450 + | let mut out = String::new();
|
14451 + | out.push_str("https://");
|
14452 + | #[allow(clippy::needless_borrow)]
|
14453 + | out.push_str(&access_point_name_ssa_2.as_ref());
|
14454 + | out.push('-');
|
14455 + | #[allow(clippy::needless_borrow)]
|
14456 + | out.push_str(&bucket_arn.account_id());
|
14457 + | out.push('.');
|
14458 + | #[allow(clippy::needless_borrow)]
|
14459 + | out.push_str(&outpost_id_ssa_1.as_ref());
|
14460 + | out.push('.');
|
14461 + | #[allow(clippy::needless_borrow)]
|
14462 + | out.push_str(&url.authority());
|
14463 + | out
|
14464 + | })
|
14465 + | .property(
|
14466 + | "authSchemes",
|
14467 + | vec![
|
14468 + | ::aws_smithy_types::Document::from({
|
14469 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14470 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14471 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
14472 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
14473 + | out.insert(
|
14474 + | "signingRegionSet".to_string(),
|
14475 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
14476 + | );
|
14477 + | out
|
14478 + | }),
|
14479 + | ::aws_smithy_types::Document::from({
|
14480 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14481 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14482 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14483 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
14484 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14485 + | out
|
14486 + | }),
|
14487 + | ],
|
14488 + | )
|
14489 + | .build(),
|
14490 + | )
|
14491 + | }
|
14492 + | Self::Result70 => {
|
14493 + | let bucket_arn = context
|
14494 + | .bucket_arn
|
14495 + | .as_ref()
|
14496 + | .map(|s| s.clone())
|
14497 + | .expect("Guaranteed to have a value by earlier checks.");
|
14498 + | let effective_arn_region = context
|
14499 + | .effective_arn_region
|
14500 + | .as_ref()
|
14501 + | .map(|s| s.clone())
|
14502 + | .expect("Guaranteed to have a value by earlier checks.");
|
14503 + | let bucket_partition = context
|
14504 + | .bucket_partition
|
14505 + | .as_ref()
|
14506 + | .map(|s| s.clone())
|
14507 + | .expect("Guaranteed to have a value by earlier checks.");
|
14508 + | let outpost_id_ssa_1 = context
|
14509 + | .outpost_id_ssa_1
|
14510 + | .as_ref()
|
14511 + | .map(|s| s.clone())
|
14512 + | .expect("Guaranteed to have a value by earlier checks.");
|
14513 + | let access_point_name_ssa_2 = context
|
14514 + | .access_point_name_ssa_2
|
14515 + | .as_ref()
|
14516 + | .map(|s| s.clone())
|
14517 + | .expect("Guaranteed to have a value by earlier checks.");
|
14518 + | ::std::result::Result::Ok(
|
14519 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14520 + | .url({
|
14521 + | let mut out = String::new();
|
14522 + | out.push_str("https://");
|
14523 + | #[allow(clippy::needless_borrow)]
|
14524 + | out.push_str(&access_point_name_ssa_2.as_ref());
|
14525 + | out.push('-');
|
14526 + | #[allow(clippy::needless_borrow)]
|
14527 + | out.push_str(&bucket_arn.account_id());
|
14528 + | out.push('.');
|
14529 + | #[allow(clippy::needless_borrow)]
|
14530 + | out.push_str(&outpost_id_ssa_1.as_ref());
|
14531 + | out.push_str(".s3-outposts.");
|
14532 + | #[allow(clippy::needless_borrow)]
|
14533 + | out.push_str(&effective_arn_region.as_ref());
|
14534 + | out.push('.');
|
14535 + | #[allow(clippy::needless_borrow)]
|
14536 + | out.push_str(&bucket_partition.dns_suffix());
|
14537 + | out
|
14538 + | })
|
14539 + | .property(
|
14540 + | "authSchemes",
|
14541 + | vec![
|
14542 + | ::aws_smithy_types::Document::from({
|
14543 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14544 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14545 + | out.insert("name".to_string(), "sigv4a".to_string().into());
|
14546 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
14547 + | out.insert(
|
14548 + | "signingRegionSet".to_string(),
|
14549 + | vec![::aws_smithy_types::Document::from("*".to_string())].into(),
|
14550 + | );
|
14551 + | out
|
14552 + | }),
|
14553 + | ::aws_smithy_types::Document::from({
|
14554 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14555 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14556 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14557 + | out.insert("signingName".to_string(), "s3-outposts".to_string().into());
|
14558 + | out.insert("signingRegion".to_string(), effective_arn_region.to_owned().into());
|
14559 + | out
|
14560 + | }),
|
14561 + | ],
|
14562 + | )
|
14563 + | .build(),
|
14564 + | )
|
14565 + | }
|
14566 + | Self::Result71 => {
|
14567 + | let outpost_type = context
|
14568 + | .outpost_type
|
14569 + | .as_ref()
|
14570 + | .map(|s| s.clone())
|
14571 + | .expect("Guaranteed to have a value by earlier checks.");
|
14572 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14573 + | let mut out = String::new();
|
14574 + | out.push_str("Expected an outpost type `accesspoint`, found ");
|
14575 + | #[allow(clippy::needless_borrow)]
|
14576 + | out.push_str(&outpost_type.as_ref());
|
14577 + | out
|
14578 + | }))
|
14579 + | }
|
14580 + | Self::Result72 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14581 + | "Invalid ARN: expected an access point name".to_string(),
|
14582 + | )),
|
14583 + | Self::Result73 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14584 + | "Invalid ARN: Expected a 4-component resource".to_string(),
|
14585 + | )),
|
14586 + | Self::Result74 => {
|
14587 + | let outpost_id_ssa_1 = context
|
14588 + | .outpost_id_ssa_1
|
14589 + | .as_ref()
|
14590 + | .map(|s| s.clone())
|
14591 + | .expect("Guaranteed to have a value by earlier checks.");
|
14592 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14593 + | let mut out = String::new();
|
14594 + | out.push_str("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
|
14595 + | #[allow(clippy::needless_borrow)]
|
14596 + | out.push_str(&outpost_id_ssa_1.as_ref());
|
14597 + | out.push('`');
|
14598 + | out
|
14599 + | }))
|
14600 + | }
|
14601 + | Self::Result75 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14602 + | "Invalid ARN: The Outpost Id was not set".to_string(),
|
14603 + | )),
|
14604 + | Self::Result76 => {
|
14605 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
14606 + | let arn_type = context
|
14607 + | .arn_type
|
14608 + | .as_ref()
|
14609 + | .map(|s| s.clone())
|
14610 + | .expect("Guaranteed to have a value by earlier checks.");
|
14611 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14612 + | let mut out = String::new();
|
14613 + | out.push_str("Invalid ARN: Unrecognized format: ");
|
14614 + | #[allow(clippy::needless_borrow)]
|
14615 + | out.push_str(&bucket.as_ref());
|
14616 + | out.push_str(" (type: ");
|
14617 + | #[allow(clippy::needless_borrow)]
|
14618 + | out.push_str(&arn_type.as_ref());
|
14619 + | out.push(')');
|
14620 + | out
|
14621 + | }))
|
14622 + | }
|
14623 + | Self::Result77 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14624 + | "Invalid ARN: No ARN type specified".to_string(),
|
14625 + | )),
|
14626 + | Self::Result78 => {
|
14627 + | let bucket = params.bucket.as_ref().map(|s| s.clone()).unwrap_or_default();
|
14628 + | ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
|
14629 + | let mut out = String::new();
|
14630 + | out.push_str("Invalid ARN: `");
|
14631 + | #[allow(clippy::needless_borrow)]
|
14632 + | out.push_str(&bucket.as_ref());
|
14633 + | out.push_str("` was not a valid ARN");
|
14634 + | out
|
14635 + | }))
|
14636 + | }
|
14637 + | Self::Result79 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14638 + | "Path-style addressing cannot be used with ARN buckets".to_string(),
|
14639 + | )),
|
14640 + | Self::Result80 => {
|
14641 + | let effective_std_region = context
|
14642 + | .effective_std_region
|
14643 + | .as_ref()
|
14644 + | .map(|s| s.clone())
|
14645 + | .expect("Guaranteed to have a value by earlier checks.");
|
14646 + | let partition_result = context
|
14647 + | .partition_result
|
14648 + | .as_ref()
|
14649 + | .map(|s| s.clone())
|
14650 + | .expect("Guaranteed to have a value by earlier checks.");
|
14651 + | let uri_encoded_bucket = context
|
14652 + | .uri_encoded_bucket
|
14653 + | .as_ref()
|
14654 + | .map(|s| s.clone())
|
14655 + | .expect("Guaranteed to have a value by earlier checks.");
|
14656 + | ::std::result::Result::Ok(
|
14657 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14658 + | .url({
|
14659 + | let mut out = String::new();
|
14660 + | out.push_str("https://s3-fips.dualstack.");
|
14661 + | #[allow(clippy::needless_borrow)]
|
14662 + | out.push_str(&effective_std_region.as_ref());
|
14663 + | out.push('.');
|
14664 + | #[allow(clippy::needless_borrow)]
|
14665 + | out.push_str(&partition_result.dns_suffix());
|
14666 + | out.push('/');
|
14667 + | #[allow(clippy::needless_borrow)]
|
14668 + | out.push_str(&uri_encoded_bucket.as_ref());
|
14669 + | out
|
14670 + | })
|
14671 + | .property(
|
14672 + | "authSchemes",
|
14673 + | vec![::aws_smithy_types::Document::from({
|
14674 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14675 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14676 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14677 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14678 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14679 + | out
|
14680 + | })],
|
14681 + | )
|
14682 + | .build(),
|
14683 + | )
|
14684 + | }
|
14685 + | Self::Result81 => {
|
14686 + | let effective_std_region = context
|
14687 + | .effective_std_region
|
14688 + | .as_ref()
|
14689 + | .map(|s| s.clone())
|
14690 + | .expect("Guaranteed to have a value by earlier checks.");
|
14691 + | let partition_result = context
|
14692 + | .partition_result
|
14693 + | .as_ref()
|
14694 + | .map(|s| s.clone())
|
14695 + | .expect("Guaranteed to have a value by earlier checks.");
|
14696 + | let uri_encoded_bucket = context
|
14697 + | .uri_encoded_bucket
|
14698 + | .as_ref()
|
14699 + | .map(|s| s.clone())
|
14700 + | .expect("Guaranteed to have a value by earlier checks.");
|
14701 + | ::std::result::Result::Ok(
|
14702 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14703 + | .url({
|
14704 + | let mut out = String::new();
|
14705 + | out.push_str("https://s3-fips.");
|
14706 + | #[allow(clippy::needless_borrow)]
|
14707 + | out.push_str(&effective_std_region.as_ref());
|
14708 + | out.push('.');
|
14709 + | #[allow(clippy::needless_borrow)]
|
14710 + | out.push_str(&partition_result.dns_suffix());
|
14711 + | out.push('/');
|
14712 + | #[allow(clippy::needless_borrow)]
|
14713 + | out.push_str(&uri_encoded_bucket.as_ref());
|
14714 + | out
|
14715 + | })
|
14716 + | .property(
|
14717 + | "authSchemes",
|
14718 + | vec![::aws_smithy_types::Document::from({
|
14719 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14720 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14721 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14722 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14723 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14724 + | out
|
14725 + | })],
|
14726 + | )
|
14727 + | .build(),
|
14728 + | )
|
14729 + | }
|
14730 + | Self::Result82 => {
|
14731 + | let effective_std_region = context
|
14732 + | .effective_std_region
|
14733 + | .as_ref()
|
14734 + | .map(|s| s.clone())
|
14735 + | .expect("Guaranteed to have a value by earlier checks.");
|
14736 + | let partition_result = context
|
14737 + | .partition_result
|
14738 + | .as_ref()
|
14739 + | .map(|s| s.clone())
|
14740 + | .expect("Guaranteed to have a value by earlier checks.");
|
14741 + | let uri_encoded_bucket = context
|
14742 + | .uri_encoded_bucket
|
14743 + | .as_ref()
|
14744 + | .map(|s| s.clone())
|
14745 + | .expect("Guaranteed to have a value by earlier checks.");
|
14746 + | ::std::result::Result::Ok(
|
14747 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14748 + | .url({
|
14749 + | let mut out = String::new();
|
14750 + | out.push_str("https://s3.dualstack.");
|
14751 + | #[allow(clippy::needless_borrow)]
|
14752 + | out.push_str(&effective_std_region.as_ref());
|
14753 + | out.push('.');
|
14754 + | #[allow(clippy::needless_borrow)]
|
14755 + | out.push_str(&partition_result.dns_suffix());
|
14756 + | out.push('/');
|
14757 + | #[allow(clippy::needless_borrow)]
|
14758 + | out.push_str(&uri_encoded_bucket.as_ref());
|
14759 + | out
|
14760 + | })
|
14761 + | .property(
|
14762 + | "authSchemes",
|
14763 + | vec![::aws_smithy_types::Document::from({
|
14764 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14765 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14766 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14767 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14768 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14769 + | out
|
14770 + | })],
|
14771 + | )
|
14772 + | .build(),
|
14773 + | )
|
14774 + | }
|
14775 + | Self::Result83 => {
|
14776 + | let effective_std_region = context
|
14777 + | .effective_std_region
|
14778 + | .as_ref()
|
14779 + | .map(|s| s.clone())
|
14780 + | .expect("Guaranteed to have a value by earlier checks.");
|
14781 + | let url = context
|
14782 + | .url
|
14783 + | .as_ref()
|
14784 + | .map(|s| s.clone())
|
14785 + | .expect("Guaranteed to have a value by earlier checks.");
|
14786 + | let uri_encoded_bucket = context
|
14787 + | .uri_encoded_bucket
|
14788 + | .as_ref()
|
14789 + | .map(|s| s.clone())
|
14790 + | .expect("Guaranteed to have a value by earlier checks.");
|
14791 + | ::std::result::Result::Ok(
|
14792 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14793 + | .url({
|
14794 + | let mut out = String::new();
|
14795 + | #[allow(clippy::needless_borrow)]
|
14796 + | out.push_str(&url.scheme());
|
14797 + | out.push_str("://");
|
14798 + | #[allow(clippy::needless_borrow)]
|
14799 + | out.push_str(&url.authority());
|
14800 + | #[allow(clippy::needless_borrow)]
|
14801 + | out.push_str(&url.normalized_path());
|
14802 + | #[allow(clippy::needless_borrow)]
|
14803 + | out.push_str(&uri_encoded_bucket.as_ref());
|
14804 + | out
|
14805 + | })
|
14806 + | .property(
|
14807 + | "authSchemes",
|
14808 + | vec![::aws_smithy_types::Document::from({
|
14809 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14810 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14811 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14812 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14813 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14814 + | out
|
14815 + | })],
|
14816 + | )
|
14817 + | .build(),
|
14818 + | )
|
14819 + | }
|
14820 + | Self::Result84 => {
|
14821 + | let effective_std_region = context
|
14822 + | .effective_std_region
|
14823 + | .as_ref()
|
14824 + | .map(|s| s.clone())
|
14825 + | .expect("Guaranteed to have a value by earlier checks.");
|
14826 + | let partition_result = context
|
14827 + | .partition_result
|
14828 + | .as_ref()
|
14829 + | .map(|s| s.clone())
|
14830 + | .expect("Guaranteed to have a value by earlier checks.");
|
14831 + | let uri_encoded_bucket = context
|
14832 + | .uri_encoded_bucket
|
14833 + | .as_ref()
|
14834 + | .map(|s| s.clone())
|
14835 + | .expect("Guaranteed to have a value by earlier checks.");
|
14836 + | ::std::result::Result::Ok(
|
14837 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14838 + | .url({
|
14839 + | let mut out = String::new();
|
14840 + | out.push_str("https://s3.");
|
14841 + | #[allow(clippy::needless_borrow)]
|
14842 + | out.push_str(&partition_result.dns_suffix());
|
14843 + | out.push('/');
|
14844 + | #[allow(clippy::needless_borrow)]
|
14845 + | out.push_str(&uri_encoded_bucket.as_ref());
|
14846 + | out
|
14847 + | })
|
14848 + | .property(
|
14849 + | "authSchemes",
|
14850 + | vec![::aws_smithy_types::Document::from({
|
14851 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14852 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14853 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14854 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14855 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14856 + | out
|
14857 + | })],
|
14858 + | )
|
14859 + | .build(),
|
14860 + | )
|
14861 + | }
|
14862 + | Self::Result85 => {
|
14863 + | let effective_std_region = context
|
14864 + | .effective_std_region
|
14865 + | .as_ref()
|
14866 + | .map(|s| s.clone())
|
14867 + | .expect("Guaranteed to have a value by earlier checks.");
|
14868 + | let partition_result = context
|
14869 + | .partition_result
|
14870 + | .as_ref()
|
14871 + | .map(|s| s.clone())
|
14872 + | .expect("Guaranteed to have a value by earlier checks.");
|
14873 + | let uri_encoded_bucket = context
|
14874 + | .uri_encoded_bucket
|
14875 + | .as_ref()
|
14876 + | .map(|s| s.clone())
|
14877 + | .expect("Guaranteed to have a value by earlier checks.");
|
14878 + | ::std::result::Result::Ok(
|
14879 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14880 + | .url({
|
14881 + | let mut out = String::new();
|
14882 + | out.push_str("https://s3.");
|
14883 + | #[allow(clippy::needless_borrow)]
|
14884 + | out.push_str(&effective_std_region.as_ref());
|
14885 + | out.push('.');
|
14886 + | #[allow(clippy::needless_borrow)]
|
14887 + | out.push_str(&partition_result.dns_suffix());
|
14888 + | out.push('/');
|
14889 + | #[allow(clippy::needless_borrow)]
|
14890 + | out.push_str(&uri_encoded_bucket.as_ref());
|
14891 + | out
|
14892 + | })
|
14893 + | .property(
|
14894 + | "authSchemes",
|
14895 + | vec![::aws_smithy_types::Document::from({
|
14896 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14897 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14898 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14899 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
14900 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14901 + | out
|
14902 + | })],
|
14903 + | )
|
14904 + | .build(),
|
14905 + | )
|
14906 + | }
|
14907 + | Self::Result86 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
14908 + | "Path-style addressing cannot be used with S3 Accelerate".to_string(),
|
14909 + | )),
|
14910 + | Self::Result87 => {
|
14911 + | let effective_std_region = context
|
14912 + | .effective_std_region
|
14913 + | .as_ref()
|
14914 + | .map(|s| s.clone())
|
14915 + | .expect("Guaranteed to have a value by earlier checks.");
|
14916 + | let url = context
|
14917 + | .url
|
14918 + | .as_ref()
|
14919 + | .map(|s| s.clone())
|
14920 + | .expect("Guaranteed to have a value by earlier checks.");
|
14921 + | ::std::result::Result::Ok(
|
14922 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14923 + | .url({
|
14924 + | let mut out = String::new();
|
14925 + | #[allow(clippy::needless_borrow)]
|
14926 + | out.push_str(&url.scheme());
|
14927 + | out.push_str("://");
|
14928 + | #[allow(clippy::needless_borrow)]
|
14929 + | out.push_str(&url.authority());
|
14930 + | #[allow(clippy::needless_borrow)]
|
14931 + | out.push_str(&url.path());
|
14932 + | out
|
14933 + | })
|
14934 + | .property(
|
14935 + | "authSchemes",
|
14936 + | vec![::aws_smithy_types::Document::from({
|
14937 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14938 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14939 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14940 + | out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
|
14941 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14942 + | out
|
14943 + | })],
|
14944 + | )
|
14945 + | .build(),
|
14946 + | )
|
14947 + | }
|
14948 + | Self::Result88 => {
|
14949 + | let effective_std_region = context
|
14950 + | .effective_std_region
|
14951 + | .as_ref()
|
14952 + | .map(|s| s.clone())
|
14953 + | .expect("Guaranteed to have a value by earlier checks.");
|
14954 + | let partition_result = context
|
14955 + | .partition_result
|
14956 + | .as_ref()
|
14957 + | .map(|s| s.clone())
|
14958 + | .expect("Guaranteed to have a value by earlier checks.");
|
14959 + | ::std::result::Result::Ok(
|
14960 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14961 + | .url({
|
14962 + | let mut out = String::new();
|
14963 + | out.push_str("https://s3-object-lambda-fips.");
|
14964 + | #[allow(clippy::needless_borrow)]
|
14965 + | out.push_str(&effective_std_region.as_ref());
|
14966 + | out.push('.');
|
14967 + | #[allow(clippy::needless_borrow)]
|
14968 + | out.push_str(&partition_result.dns_suffix());
|
14969 + | out
|
14970 + | })
|
14971 + | .property(
|
14972 + | "authSchemes",
|
14973 + | vec![::aws_smithy_types::Document::from({
|
14974 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
14975 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
14976 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
14977 + | out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
|
14978 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
14979 + | out
|
14980 + | })],
|
14981 + | )
|
14982 + | .build(),
|
14983 + | )
|
14984 + | }
|
14985 + | Self::Result89 => {
|
14986 + | let effective_std_region = context
|
14987 + | .effective_std_region
|
14988 + | .as_ref()
|
14989 + | .map(|s| s.clone())
|
14990 + | .expect("Guaranteed to have a value by earlier checks.");
|
14991 + | let partition_result = context
|
14992 + | .partition_result
|
14993 + | .as_ref()
|
14994 + | .map(|s| s.clone())
|
14995 + | .expect("Guaranteed to have a value by earlier checks.");
|
14996 + | ::std::result::Result::Ok(
|
14997 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
14998 + | .url({
|
14999 + | let mut out = String::new();
|
15000 + | out.push_str("https://s3-object-lambda.");
|
15001 + | #[allow(clippy::needless_borrow)]
|
15002 + | out.push_str(&effective_std_region.as_ref());
|
15003 + | out.push('.');
|
15004 + | #[allow(clippy::needless_borrow)]
|
15005 + | out.push_str(&partition_result.dns_suffix());
|
15006 + | out
|
15007 + | })
|
15008 + | .property(
|
15009 + | "authSchemes",
|
15010 + | vec![::aws_smithy_types::Document::from({
|
15011 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15012 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15013 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15014 + | out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
|
15015 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15016 + | out
|
15017 + | })],
|
15018 + | )
|
15019 + | .build(),
|
15020 + | )
|
15021 + | }
|
15022 + | Self::Result90 => {
|
15023 + | let effective_std_region = context
|
15024 + | .effective_std_region
|
15025 + | .as_ref()
|
15026 + | .map(|s| s.clone())
|
15027 + | .expect("Guaranteed to have a value by earlier checks.");
|
15028 + | let partition_result = context
|
15029 + | .partition_result
|
15030 + | .as_ref()
|
15031 + | .map(|s| s.clone())
|
15032 + | .expect("Guaranteed to have a value by earlier checks.");
|
15033 + | ::std::result::Result::Ok(
|
15034 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
15035 + | .url({
|
15036 + | let mut out = String::new();
|
15037 + | out.push_str("https://s3-fips.dualstack.");
|
15038 + | #[allow(clippy::needless_borrow)]
|
15039 + | out.push_str(&effective_std_region.as_ref());
|
15040 + | out.push('.');
|
15041 + | #[allow(clippy::needless_borrow)]
|
15042 + | out.push_str(&partition_result.dns_suffix());
|
15043 + | out
|
15044 + | })
|
15045 + | .property(
|
15046 + | "authSchemes",
|
15047 + | vec![::aws_smithy_types::Document::from({
|
15048 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15049 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15050 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15051 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
15052 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15053 + | out
|
15054 + | })],
|
15055 + | )
|
15056 + | .build(),
|
15057 + | )
|
15058 + | }
|
15059 + | Self::Result91 => {
|
15060 + | let effective_std_region = context
|
15061 + | .effective_std_region
|
15062 + | .as_ref()
|
15063 + | .map(|s| s.clone())
|
15064 + | .expect("Guaranteed to have a value by earlier checks.");
|
15065 + | let partition_result = context
|
15066 + | .partition_result
|
15067 + | .as_ref()
|
15068 + | .map(|s| s.clone())
|
15069 + | .expect("Guaranteed to have a value by earlier checks.");
|
15070 + | ::std::result::Result::Ok(
|
15071 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
15072 + | .url({
|
15073 + | let mut out = String::new();
|
15074 + | out.push_str("https://s3-fips.");
|
15075 + | #[allow(clippy::needless_borrow)]
|
15076 + | out.push_str(&effective_std_region.as_ref());
|
15077 + | out.push('.');
|
15078 + | #[allow(clippy::needless_borrow)]
|
15079 + | out.push_str(&partition_result.dns_suffix());
|
15080 + | out
|
15081 + | })
|
15082 + | .property(
|
15083 + | "authSchemes",
|
15084 + | vec![::aws_smithy_types::Document::from({
|
15085 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15086 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15087 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15088 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
15089 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15090 + | out
|
15091 + | })],
|
15092 + | )
|
15093 + | .build(),
|
15094 + | )
|
15095 + | }
|
15096 + | Self::Result92 => {
|
15097 + | let effective_std_region = context
|
15098 + | .effective_std_region
|
15099 + | .as_ref()
|
15100 + | .map(|s| s.clone())
|
15101 + | .expect("Guaranteed to have a value by earlier checks.");
|
15102 + | let partition_result = context
|
15103 + | .partition_result
|
15104 + | .as_ref()
|
15105 + | .map(|s| s.clone())
|
15106 + | .expect("Guaranteed to have a value by earlier checks.");
|
15107 + | ::std::result::Result::Ok(
|
15108 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
15109 + | .url({
|
15110 + | let mut out = String::new();
|
15111 + | out.push_str("https://s3.dualstack.");
|
15112 + | #[allow(clippy::needless_borrow)]
|
15113 + | out.push_str(&effective_std_region.as_ref());
|
15114 + | out.push('.');
|
15115 + | #[allow(clippy::needless_borrow)]
|
15116 + | out.push_str(&partition_result.dns_suffix());
|
15117 + | out
|
15118 + | })
|
15119 + | .property(
|
15120 + | "authSchemes",
|
15121 + | vec![::aws_smithy_types::Document::from({
|
15122 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15123 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15124 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15125 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
15126 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15127 + | out
|
15128 + | })],
|
15129 + | )
|
15130 + | .build(),
|
15131 + | )
|
15132 + | }
|
15133 + | Self::Result93 => {
|
15134 + | let effective_std_region = context
|
15135 + | .effective_std_region
|
15136 + | .as_ref()
|
15137 + | .map(|s| s.clone())
|
15138 + | .expect("Guaranteed to have a value by earlier checks.");
|
15139 + | let url = context
|
15140 + | .url
|
15141 + | .as_ref()
|
15142 + | .map(|s| s.clone())
|
15143 + | .expect("Guaranteed to have a value by earlier checks.");
|
15144 + | ::std::result::Result::Ok(
|
15145 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
15146 + | .url({
|
15147 + | let mut out = String::new();
|
15148 + | #[allow(clippy::needless_borrow)]
|
15149 + | out.push_str(&url.scheme());
|
15150 + | out.push_str("://");
|
15151 + | #[allow(clippy::needless_borrow)]
|
15152 + | out.push_str(&url.authority());
|
15153 + | #[allow(clippy::needless_borrow)]
|
15154 + | out.push_str(&url.path());
|
15155 + | out
|
15156 + | })
|
15157 + | .property(
|
15158 + | "authSchemes",
|
15159 + | vec![::aws_smithy_types::Document::from({
|
15160 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15161 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15162 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15163 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
15164 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15165 + | out
|
15166 + | })],
|
15167 + | )
|
15168 + | .build(),
|
15169 + | )
|
15170 + | }
|
15171 + | Self::Result94 => {
|
15172 + | let effective_std_region = context
|
15173 + | .effective_std_region
|
15174 + | .as_ref()
|
15175 + | .map(|s| s.clone())
|
15176 + | .expect("Guaranteed to have a value by earlier checks.");
|
15177 + | let partition_result = context
|
15178 + | .partition_result
|
15179 + | .as_ref()
|
15180 + | .map(|s| s.clone())
|
15181 + | .expect("Guaranteed to have a value by earlier checks.");
|
15182 + | ::std::result::Result::Ok(
|
15183 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
15184 + | .url({
|
15185 + | let mut out = String::new();
|
15186 + | out.push_str("https://s3.");
|
15187 + | #[allow(clippy::needless_borrow)]
|
15188 + | out.push_str(&partition_result.dns_suffix());
|
15189 + | out
|
15190 + | })
|
15191 + | .property(
|
15192 + | "authSchemes",
|
15193 + | vec![::aws_smithy_types::Document::from({
|
15194 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15195 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15196 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15197 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
15198 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15199 + | out
|
15200 + | })],
|
15201 + | )
|
15202 + | .build(),
|
15203 + | )
|
15204 + | }
|
15205 + | Self::Result95 => {
|
15206 + | let effective_std_region = context
|
15207 + | .effective_std_region
|
15208 + | .as_ref()
|
15209 + | .map(|s| s.clone())
|
15210 + | .expect("Guaranteed to have a value by earlier checks.");
|
15211 + | let partition_result = context
|
15212 + | .partition_result
|
15213 + | .as_ref()
|
15214 + | .map(|s| s.clone())
|
15215 + | .expect("Guaranteed to have a value by earlier checks.");
|
15216 + | ::std::result::Result::Ok(
|
15217 + | ::aws_smithy_types::endpoint::Endpoint::builder()
|
15218 + | .url({
|
15219 + | let mut out = String::new();
|
15220 + | out.push_str("https://s3.");
|
15221 + | #[allow(clippy::needless_borrow)]
|
15222 + | out.push_str(&effective_std_region.as_ref());
|
15223 + | out.push('.');
|
15224 + | #[allow(clippy::needless_borrow)]
|
15225 + | out.push_str(&partition_result.dns_suffix());
|
15226 + | out
|
15227 + | })
|
15228 + | .property(
|
15229 + | "authSchemes",
|
15230 + | vec![::aws_smithy_types::Document::from({
|
15231 + | let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
|
15232 + | out.insert("disableDoubleEncoding".to_string(), true.into());
|
15233 + | out.insert("name".to_string(), "sigv4".to_string().into());
|
15234 + | out.insert("signingName".to_string(), "s3".to_string().into());
|
15235 + | out.insert("signingRegion".to_string(), effective_std_region.to_owned().into());
|
15236 + | out
|
15237 + | })],
|
15238 + | )
|
15239 + | .build(),
|
15240 + | )
|
15241 + | }
|
15242 + | Self::Result96 => ::std::result::Result::Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
|
15243 + | "A region must be set when sending requests to S3.".to_string(),
|
15244 + | )),
|
15245 + | }
|
10301 15246 | }
|
10302 15247 | }
|
10303 15248 |
|
15249 + | const RESULTS: [ResultEndpoint; 97] = [
|
15250 + | ResultEndpoint::Result0,
|
15251 + | ResultEndpoint::Result1,
|
15252 + | ResultEndpoint::Result2,
|
15253 + | ResultEndpoint::Result3,
|
15254 + | ResultEndpoint::Result4,
|
15255 + | ResultEndpoint::Result5,
|
15256 + | ResultEndpoint::Result6,
|
15257 + | ResultEndpoint::Result7,
|
15258 + | ResultEndpoint::Result8,
|
15259 + | ResultEndpoint::Result9,
|
15260 + | ResultEndpoint::Result10,
|
15261 + | ResultEndpoint::Result11,
|
15262 + | ResultEndpoint::Result12,
|
15263 + | ResultEndpoint::Result13,
|
15264 + | ResultEndpoint::Result14,
|
15265 + | ResultEndpoint::Result15,
|
15266 + | ResultEndpoint::Result16,
|
15267 + | ResultEndpoint::Result17,
|
15268 + | ResultEndpoint::Result18,
|
15269 + | ResultEndpoint::Result19,
|
15270 + | ResultEndpoint::Result20,
|
15271 + | ResultEndpoint::Result21,
|
15272 + | ResultEndpoint::Result22,
|
15273 + | ResultEndpoint::Result23,
|
15274 + | ResultEndpoint::Result24,
|
15275 + | ResultEndpoint::Result25,
|
15276 + | ResultEndpoint::Result26,
|
15277 + | ResultEndpoint::Result27,
|
15278 + | ResultEndpoint::Result28,
|
15279 + | ResultEndpoint::Result29,
|
15280 + | ResultEndpoint::Result30,
|
15281 + | ResultEndpoint::Result31,
|
15282 + | ResultEndpoint::Result32,
|
15283 + | ResultEndpoint::Result33,
|
15284 + | ResultEndpoint::Result34,
|
15285 + | ResultEndpoint::Result35,
|
15286 + | ResultEndpoint::Result36,
|
15287 + | ResultEndpoint::Result37,
|
15288 + | ResultEndpoint::Result38,
|
15289 + | ResultEndpoint::Result39,
|
15290 + | ResultEndpoint::Result40,
|
15291 + | ResultEndpoint::Result41,
|
15292 + | ResultEndpoint::Result42,
|
15293 + | ResultEndpoint::Result43,
|
15294 + | ResultEndpoint::Result44,
|
15295 + | ResultEndpoint::Result45,
|
15296 + | ResultEndpoint::Result46,
|
15297 + | ResultEndpoint::Result47,
|
15298 + | ResultEndpoint::Result48,
|
15299 + | ResultEndpoint::Result49,
|
15300 + | ResultEndpoint::Result50,
|
15301 + | ResultEndpoint::Result51,
|
15302 + | ResultEndpoint::Result52,
|
15303 + | ResultEndpoint::Result53,
|
15304 + | ResultEndpoint::Result54,
|
15305 + | ResultEndpoint::Result55,
|
15306 + | ResultEndpoint::Result56,
|
15307 + | ResultEndpoint::Result57,
|
15308 + | ResultEndpoint::Result58,
|
15309 + | ResultEndpoint::Result59,
|
15310 + | ResultEndpoint::Result60,
|
15311 + | ResultEndpoint::Result61,
|
15312 + | ResultEndpoint::Result62,
|
15313 + | ResultEndpoint::Result63,
|
15314 + | ResultEndpoint::Result64,
|
15315 + | ResultEndpoint::Result65,
|
15316 + | ResultEndpoint::Result66,
|
15317 + | ResultEndpoint::Result67,
|
15318 + | ResultEndpoint::Result68,
|
15319 + | ResultEndpoint::Result69,
|
15320 + | ResultEndpoint::Result70,
|
15321 + | ResultEndpoint::Result71,
|
15322 + | ResultEndpoint::Result72,
|
15323 + | ResultEndpoint::Result73,
|
15324 + | ResultEndpoint::Result74,
|
15325 + | ResultEndpoint::Result75,
|
15326 + | ResultEndpoint::Result76,
|
15327 + | ResultEndpoint::Result77,
|
15328 + | ResultEndpoint::Result78,
|
15329 + | ResultEndpoint::Result79,
|
15330 + | ResultEndpoint::Result80,
|
15331 + | ResultEndpoint::Result81,
|
15332 + | ResultEndpoint::Result82,
|
15333 + | ResultEndpoint::Result83,
|
15334 + | ResultEndpoint::Result84,
|
15335 + | ResultEndpoint::Result85,
|
15336 + | ResultEndpoint::Result86,
|
15337 + | ResultEndpoint::Result87,
|
15338 + | ResultEndpoint::Result88,
|
15339 + | ResultEndpoint::Result89,
|
15340 + | ResultEndpoint::Result90,
|
15341 + | ResultEndpoint::Result91,
|
15342 + | ResultEndpoint::Result92,
|
15343 + | ResultEndpoint::Result93,
|
15344 + | ResultEndpoint::Result94,
|
15345 + | ResultEndpoint::Result95,
|
15346 + | ResultEndpoint::Result96,
|
15347 + | ];
|
15348 + | const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 521] = [
|
15349 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15350 + | condition_index: -1,
|
15351 + | high_ref: 1,
|
15352 + | low_ref: -1,
|
15353 + | },
|
15354 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15355 + | condition_index: 5,
|
15356 + | high_ref: 100000002,
|
15357 + | low_ref: 100000004,
|
15358 + | },
|
15359 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15360 + | condition_index: 55,
|
15361 + | high_ref: 100000015,
|
15362 + | low_ref: 100000020,
|
15363 + | },
|
15364 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15365 + | condition_index: 46,
|
15366 + | high_ref: 100000015,
|
15367 + | low_ref: 3,
|
15368 + | },
|
15369 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15370 + | condition_index: 55,
|
15371 + | high_ref: 100000019,
|
15372 + | low_ref: 100000020,
|
15373 + | },
|
15374 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15375 + | condition_index: 46,
|
15376 + | high_ref: 100000017,
|
15377 + | low_ref: 5,
|
15378 + | },
|
15379 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15380 + | condition_index: 25,
|
15381 + | high_ref: 4,
|
15382 + | low_ref: 6,
|
15383 + | },
|
15384 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15385 + | condition_index: 23,
|
15386 + | high_ref: 7,
|
15387 + | low_ref: 100000021,
|
15388 + | },
|
15389 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15390 + | condition_index: 44,
|
15391 + | high_ref: 100000035,
|
15392 + | low_ref: 100000034,
|
15393 + | },
|
15394 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15395 + | condition_index: 37,
|
15396 + | high_ref: 9,
|
15397 + | low_ref: 100000096,
|
15398 + | },
|
15399 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15400 + | condition_index: 36,
|
15401 + | high_ref: 100000086,
|
15402 + | low_ref: 10,
|
15403 + | },
|
15404 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15405 + | condition_index: 35,
|
15406 + | high_ref: 100000078,
|
15407 + | low_ref: 11,
|
15408 + | },
|
15409 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15410 + | condition_index: 31,
|
15411 + | high_ref: 100000079,
|
15412 + | low_ref: 12,
|
15413 + | },
|
15414 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15415 + | condition_index: 30,
|
15416 + | high_ref: 100000023,
|
15417 + | low_ref: 100000034,
|
15418 + | },
|
15419 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15420 + | condition_index: 73,
|
15421 + | high_ref: 100000058,
|
15422 + | low_ref: 100000064,
|
15423 + | },
|
15424 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15425 + | condition_index: 71,
|
15426 + | high_ref: 100000051,
|
15427 + | low_ref: 100000043,
|
15428 + | },
|
15429 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15430 + | condition_index: 70,
|
15431 + | high_ref: 16,
|
15432 + | low_ref: 100000044,
|
15433 + | },
|
15434 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15435 + | condition_index: 68,
|
15436 + | high_ref: 17,
|
15437 + | low_ref: 100000057,
|
15438 + | },
|
15439 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15440 + | condition_index: 67,
|
15441 + | high_ref: 18,
|
15442 + | low_ref: 100000045,
|
15443 + | },
|
15444 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15445 + | condition_index: 66,
|
15446 + | high_ref: 19,
|
15447 + | low_ref: 100000046,
|
15448 + | },
|
15449 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15450 + | condition_index: 65,
|
15451 + | high_ref: 100000047,
|
15452 + | low_ref: 20,
|
15453 + | },
|
15454 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15455 + | condition_index: 65,
|
15456 + | high_ref: 100000047,
|
15457 + | low_ref: 100000038,
|
15458 + | },
|
15459 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15460 + | condition_index: 59,
|
15461 + | high_ref: 21,
|
15462 + | low_ref: 22,
|
15463 + | },
|
15464 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15465 + | condition_index: 58,
|
15466 + | high_ref: 21,
|
15467 + | low_ref: 23,
|
15468 + | },
|
15469 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15470 + | condition_index: 59,
|
15471 + | high_ref: 100000047,
|
15472 + | low_ref: 22,
|
15473 + | },
|
15474 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15475 + | condition_index: 58,
|
15476 + | high_ref: 100000047,
|
15477 + | low_ref: 25,
|
15478 + | },
|
15479 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15480 + | condition_index: 54,
|
15481 + | high_ref: 24,
|
15482 + | low_ref: 26,
|
15483 + | },
|
15484 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15485 + | condition_index: 53,
|
15486 + | high_ref: 100000037,
|
15487 + | low_ref: 27,
|
15488 + | },
|
15489 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15490 + | condition_index: 45,
|
15491 + | high_ref: 15,
|
15492 + | low_ref: 28,
|
15493 + | },
|
15494 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15495 + | condition_index: 43,
|
15496 + | high_ref: 100000035,
|
15497 + | low_ref: 29,
|
15498 + | },
|
15499 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15500 + | condition_index: 42,
|
15501 + | high_ref: 100000049,
|
15502 + | low_ref: 30,
|
15503 + | },
|
15504 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15505 + | condition_index: 41,
|
15506 + | high_ref: 31,
|
15507 + | low_ref: 100000049,
|
15508 + | },
|
15509 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15510 + | condition_index: 52,
|
15511 + | high_ref: 100000065,
|
15512 + | low_ref: 100000076,
|
15513 + | },
|
15514 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15515 + | condition_index: 43,
|
15516 + | high_ref: 100000050,
|
15517 + | low_ref: 33,
|
15518 + | },
|
15519 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15520 + | condition_index: 40,
|
15521 + | high_ref: 32,
|
15522 + | low_ref: 34,
|
15523 + | },
|
15524 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15525 + | condition_index: 39,
|
15526 + | high_ref: 100000077,
|
15527 + | low_ref: 35,
|
15528 + | },
|
15529 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15530 + | condition_index: 38,
|
15531 + | high_ref: 36,
|
15532 + | low_ref: 100000077,
|
15533 + | },
|
15534 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15535 + | condition_index: 33,
|
15536 + | high_ref: 37,
|
15537 + | low_ref: 11,
|
15538 + | },
|
15539 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15540 + | condition_index: 31,
|
15541 + | high_ref: 38,
|
15542 + | low_ref: 12,
|
15543 + | },
|
15544 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15545 + | condition_index: 21,
|
15546 + | high_ref: 14,
|
15547 + | low_ref: 39,
|
15548 + | },
|
15549 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15550 + | condition_index: 19,
|
15551 + | high_ref: 13,
|
15552 + | low_ref: 40,
|
15553 + | },
|
15554 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15555 + | condition_index: 60,
|
15556 + | high_ref: 100000026,
|
15557 + | low_ref: 100000027,
|
15558 + | },
|
15559 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15560 + | condition_index: 30,
|
15561 + | high_ref: 42,
|
15562 + | low_ref: 100000034,
|
15563 + | },
|
15564 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15565 + | condition_index: 21,
|
15566 + | high_ref: 43,
|
15567 + | low_ref: 39,
|
15568 + | },
|
15569 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15570 + | condition_index: 19,
|
15571 + | high_ref: 13,
|
15572 + | low_ref: 44,
|
15573 + | },
|
15574 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15575 + | condition_index: 16,
|
15576 + | high_ref: 41,
|
15577 + | low_ref: 45,
|
15578 + | },
|
15579 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15580 + | condition_index: 15,
|
15581 + | high_ref: 8,
|
15582 + | low_ref: 46,
|
15583 + | },
|
15584 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15585 + | condition_index: 14,
|
15586 + | high_ref: 47,
|
15587 + | low_ref: 46,
|
15588 + | },
|
15589 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15590 + | condition_index: 13,
|
15591 + | high_ref: 48,
|
15592 + | low_ref: 46,
|
15593 + | },
|
15594 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15595 + | condition_index: 12,
|
15596 + | high_ref: 49,
|
15597 + | low_ref: 46,
|
15598 + | },
|
15599 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15600 + | condition_index: 11,
|
15601 + | high_ref: 50,
|
15602 + | low_ref: 46,
|
15603 + | },
|
15604 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15605 + | condition_index: 35,
|
15606 + | high_ref: 100000078,
|
15607 + | low_ref: 100000096,
|
15608 + | },
|
15609 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15610 + | condition_index: 31,
|
15611 + | high_ref: 100000079,
|
15612 + | low_ref: 52,
|
15613 + | },
|
15614 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15615 + | condition_index: 53,
|
15616 + | high_ref: 100000037,
|
15617 + | low_ref: 26,
|
15618 + | },
|
15619 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15620 + | condition_index: 45,
|
15621 + | high_ref: 15,
|
15622 + | low_ref: 54,
|
15623 + | },
|
15624 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15625 + | condition_index: 43,
|
15626 + | high_ref: 100000035,
|
15627 + | low_ref: 55,
|
15628 + | },
|
15629 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15630 + | condition_index: 42,
|
15631 + | high_ref: 100000049,
|
15632 + | low_ref: 56,
|
15633 + | },
|
15634 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15635 + | condition_index: 41,
|
15636 + | high_ref: 57,
|
15637 + | low_ref: 100000049,
|
15638 + | },
|
15639 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15640 + | condition_index: 40,
|
15641 + | high_ref: 58,
|
15642 + | low_ref: 34,
|
15643 + | },
|
15644 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15645 + | condition_index: 39,
|
15646 + | high_ref: 100000077,
|
15647 + | low_ref: 59,
|
15648 + | },
|
15649 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15650 + | condition_index: 38,
|
15651 + | high_ref: 60,
|
15652 + | low_ref: 100000077,
|
15653 + | },
|
15654 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15655 + | condition_index: 33,
|
15656 + | high_ref: 61,
|
15657 + | low_ref: 100000096,
|
15658 + | },
|
15659 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15660 + | condition_index: 31,
|
15661 + | high_ref: 62,
|
15662 + | low_ref: 52,
|
15663 + | },
|
15664 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15665 + | condition_index: 19,
|
15666 + | high_ref: 53,
|
15667 + | low_ref: 63,
|
15668 + | },
|
15669 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15670 + | condition_index: 9,
|
15671 + | high_ref: 51,
|
15672 + | low_ref: 64,
|
15673 + | },
|
15674 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15675 + | condition_index: 8,
|
15676 + | high_ref: 100000006,
|
15677 + | low_ref: 65,
|
15678 + | },
|
15679 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15680 + | condition_index: 7,
|
15681 + | high_ref: 100000006,
|
15682 + | low_ref: 66,
|
15683 + | },
|
15684 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15685 + | condition_index: 44,
|
15686 + | high_ref: 100000092,
|
15687 + | low_ref: 100000034,
|
15688 + | },
|
15689 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15690 + | condition_index: 37,
|
15691 + | high_ref: 9,
|
15692 + | low_ref: 68,
|
15693 + | },
|
15694 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15695 + | condition_index: 24,
|
15696 + | high_ref: 100000014,
|
15697 + | low_ref: 69,
|
15698 + | },
|
15699 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15700 + | condition_index: 20,
|
15701 + | high_ref: 70,
|
15702 + | low_ref: 69,
|
15703 + | },
|
15704 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15705 + | condition_index: 18,
|
15706 + | high_ref: 71,
|
15707 + | low_ref: 69,
|
15708 + | },
|
15709 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15710 + | condition_index: 17,
|
15711 + | high_ref: 72,
|
15712 + | low_ref: 69,
|
15713 + | },
|
15714 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15715 + | condition_index: 9,
|
15716 + | high_ref: 73,
|
15717 + | low_ref: 100000096,
|
15718 + | },
|
15719 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15720 + | condition_index: 6,
|
15721 + | high_ref: 67,
|
15722 + | low_ref: 74,
|
15723 + | },
|
15724 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15725 + | condition_index: 44,
|
15726 + | high_ref: 100000036,
|
15727 + | low_ref: 100000034,
|
15728 + | },
|
15729 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15730 + | condition_index: 37,
|
15731 + | high_ref: 76,
|
15732 + | low_ref: 100000096,
|
15733 + | },
|
15734 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15735 + | condition_index: 36,
|
15736 + | high_ref: 100000086,
|
15737 + | low_ref: 77,
|
15738 + | },
|
15739 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15740 + | condition_index: 35,
|
15741 + | high_ref: 100000078,
|
15742 + | low_ref: 78,
|
15743 + | },
|
15744 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15745 + | condition_index: 31,
|
15746 + | high_ref: 100000079,
|
15747 + | low_ref: 79,
|
15748 + | },
|
15749 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15750 + | condition_index: 73,
|
15751 + | high_ref: 100000060,
|
15752 + | low_ref: 100000064,
|
15753 + | },
|
15754 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15755 + | condition_index: 45,
|
15756 + | high_ref: 81,
|
15757 + | low_ref: 28,
|
15758 + | },
|
15759 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15760 + | condition_index: 43,
|
15761 + | high_ref: 100000036,
|
15762 + | low_ref: 82,
|
15763 + | },
|
15764 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15765 + | condition_index: 42,
|
15766 + | high_ref: 100000049,
|
15767 + | low_ref: 83,
|
15768 + | },
|
15769 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15770 + | condition_index: 41,
|
15771 + | high_ref: 84,
|
15772 + | low_ref: 100000049,
|
15773 + | },
|
15774 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15775 + | condition_index: 52,
|
15776 + | high_ref: 100000067,
|
15777 + | low_ref: 100000076,
|
15778 + | },
|
15779 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15780 + | condition_index: 43,
|
15781 + | high_ref: 100000050,
|
15782 + | low_ref: 86,
|
15783 + | },
|
15784 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15785 + | condition_index: 40,
|
15786 + | high_ref: 85,
|
15787 + | low_ref: 87,
|
15788 + | },
|
15789 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15790 + | condition_index: 39,
|
15791 + | high_ref: 100000077,
|
15792 + | low_ref: 88,
|
15793 + | },
|
15794 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15795 + | condition_index: 38,
|
15796 + | high_ref: 89,
|
15797 + | low_ref: 100000077,
|
15798 + | },
|
15799 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15800 + | condition_index: 33,
|
15801 + | high_ref: 90,
|
15802 + | low_ref: 78,
|
15803 + | },
|
15804 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15805 + | condition_index: 31,
|
15806 + | high_ref: 91,
|
15807 + | low_ref: 79,
|
15808 + | },
|
15809 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15810 + | condition_index: 21,
|
15811 + | high_ref: 14,
|
15812 + | low_ref: 92,
|
15813 + | },
|
15814 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15815 + | condition_index: 19,
|
15816 + | high_ref: 80,
|
15817 + | low_ref: 93,
|
15818 + | },
|
15819 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15820 + | condition_index: 30,
|
15821 + | high_ref: 100000031,
|
15822 + | low_ref: 100000034,
|
15823 + | },
|
15824 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15825 + | condition_index: 21,
|
15826 + | high_ref: 95,
|
15827 + | low_ref: 92,
|
15828 + | },
|
15829 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15830 + | condition_index: 19,
|
15831 + | high_ref: 80,
|
15832 + | low_ref: 96,
|
15833 + | },
|
15834 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15835 + | condition_index: 16,
|
15836 + | high_ref: 94,
|
15837 + | low_ref: 97,
|
15838 + | },
|
15839 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15840 + | condition_index: 15,
|
15841 + | high_ref: 8,
|
15842 + | low_ref: 98,
|
15843 + | },
|
15844 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15845 + | condition_index: 14,
|
15846 + | high_ref: 99,
|
15847 + | low_ref: 98,
|
15848 + | },
|
15849 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15850 + | condition_index: 13,
|
15851 + | high_ref: 100,
|
15852 + | low_ref: 98,
|
15853 + | },
|
15854 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15855 + | condition_index: 12,
|
15856 + | high_ref: 101,
|
15857 + | low_ref: 98,
|
15858 + | },
|
15859 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15860 + | condition_index: 11,
|
15861 + | high_ref: 102,
|
15862 + | low_ref: 98,
|
15863 + | },
|
15864 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15865 + | condition_index: 45,
|
15866 + | high_ref: 81,
|
15867 + | low_ref: 54,
|
15868 + | },
|
15869 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15870 + | condition_index: 43,
|
15871 + | high_ref: 100000036,
|
15872 + | low_ref: 104,
|
15873 + | },
|
15874 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15875 + | condition_index: 42,
|
15876 + | high_ref: 100000049,
|
15877 + | low_ref: 105,
|
15878 + | },
|
15879 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15880 + | condition_index: 41,
|
15881 + | high_ref: 106,
|
15882 + | low_ref: 100000049,
|
15883 + | },
|
15884 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15885 + | condition_index: 40,
|
15886 + | high_ref: 107,
|
15887 + | low_ref: 87,
|
15888 + | },
|
15889 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15890 + | condition_index: 39,
|
15891 + | high_ref: 100000077,
|
15892 + | low_ref: 108,
|
15893 + | },
|
15894 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15895 + | condition_index: 38,
|
15896 + | high_ref: 109,
|
15897 + | low_ref: 100000077,
|
15898 + | },
|
15899 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15900 + | condition_index: 33,
|
15901 + | high_ref: 110,
|
15902 + | low_ref: 100000096,
|
15903 + | },
|
15904 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15905 + | condition_index: 31,
|
15906 + | high_ref: 111,
|
15907 + | low_ref: 52,
|
15908 + | },
|
15909 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15910 + | condition_index: 19,
|
15911 + | high_ref: 53,
|
15912 + | low_ref: 112,
|
15913 + | },
|
15914 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15915 + | condition_index: 9,
|
15916 + | high_ref: 103,
|
15917 + | low_ref: 113,
|
15918 + | },
|
15919 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15920 + | condition_index: 8,
|
15921 + | high_ref: 100000006,
|
15922 + | low_ref: 114,
|
15923 + | },
|
15924 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15925 + | condition_index: 7,
|
15926 + | high_ref: 100000006,
|
15927 + | low_ref: 115,
|
15928 + | },
|
15929 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15930 + | condition_index: 63,
|
15931 + | high_ref: 100000094,
|
15932 + | low_ref: 100000095,
|
15933 + | },
|
15934 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15935 + | condition_index: 61,
|
15936 + | high_ref: 117,
|
15937 + | low_ref: 100000095,
|
15938 + | },
|
15939 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15940 + | condition_index: 60,
|
15941 + | high_ref: 100000094,
|
15942 + | low_ref: 118,
|
15943 + | },
|
15944 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15945 + | condition_index: 44,
|
15946 + | high_ref: 119,
|
15947 + | low_ref: 100000034,
|
15948 + | },
|
15949 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15950 + | condition_index: 37,
|
15951 + | high_ref: 76,
|
15952 + | low_ref: 120,
|
15953 + | },
|
15954 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15955 + | condition_index: 24,
|
15956 + | high_ref: 100000014,
|
15957 + | low_ref: 121,
|
15958 + | },
|
15959 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15960 + | condition_index: 20,
|
15961 + | high_ref: 122,
|
15962 + | low_ref: 121,
|
15963 + | },
|
15964 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15965 + | condition_index: 18,
|
15966 + | high_ref: 123,
|
15967 + | low_ref: 121,
|
15968 + | },
|
15969 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15970 + | condition_index: 17,
|
15971 + | high_ref: 124,
|
15972 + | low_ref: 121,
|
15973 + | },
|
15974 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15975 + | condition_index: 9,
|
15976 + | high_ref: 125,
|
15977 + | low_ref: 100000096,
|
15978 + | },
|
15979 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15980 + | condition_index: 6,
|
15981 + | high_ref: 116,
|
15982 + | low_ref: 126,
|
15983 + | },
|
15984 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15985 + | condition_index: 5,
|
15986 + | high_ref: 75,
|
15987 + | low_ref: 127,
|
15988 + | },
|
15989 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15990 + | condition_index: 4,
|
15991 + | high_ref: 2,
|
15992 + | low_ref: 128,
|
15993 + | },
|
15994 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
15995 + | condition_index: 3,
|
15996 + | high_ref: 100000001,
|
15997 + | low_ref: 129,
|
15998 + | },
|
15999 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16000 + | condition_index: 5,
|
16001 + | high_ref: 100000002,
|
16002 + | low_ref: 100000003,
|
16003 + | },
|
16004 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16005 + | condition_index: 51,
|
16006 + | high_ref: 100000011,
|
16007 + | low_ref: 100000012,
|
16008 + | },
|
16009 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16010 + | condition_index: 50,
|
16011 + | high_ref: 100000011,
|
16012 + | low_ref: 132,
|
16013 + | },
|
16014 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16015 + | condition_index: 49,
|
16016 + | high_ref: 100000011,
|
16017 + | low_ref: 133,
|
16018 + | },
|
16019 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16020 + | condition_index: 48,
|
16021 + | high_ref: 100000011,
|
16022 + | low_ref: 134,
|
16023 + | },
|
16024 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16025 + | condition_index: 47,
|
16026 + | high_ref: 100000011,
|
16027 + | low_ref: 135,
|
16028 + | },
|
16029 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16030 + | condition_index: 36,
|
16031 + | high_ref: 100000010,
|
16032 + | low_ref: 136,
|
16033 + | },
|
16034 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16035 + | condition_index: 24,
|
16036 + | high_ref: 137,
|
16037 + | low_ref: 136,
|
16038 + | },
|
16039 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16040 + | condition_index: 36,
|
16041 + | high_ref: 100000010,
|
16042 + | low_ref: 100000012,
|
16043 + | },
|
16044 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16045 + | condition_index: 24,
|
16046 + | high_ref: 139,
|
16047 + | low_ref: 100000012,
|
16048 + | },
|
16049 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16050 + | condition_index: 22,
|
16051 + | high_ref: 138,
|
16052 + | low_ref: 140,
|
16053 + | },
|
16054 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16055 + | condition_index: 36,
|
16056 + | high_ref: 100000010,
|
16057 + | low_ref: 100000009,
|
16058 + | },
|
16059 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16060 + | condition_index: 24,
|
16061 + | high_ref: 142,
|
16062 + | low_ref: 100000009,
|
16063 + | },
|
16064 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16065 + | condition_index: 21,
|
16066 + | high_ref: 141,
|
16067 + | low_ref: 143,
|
16068 + | },
|
16069 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16070 + | condition_index: 21,
|
16071 + | high_ref: 100000012,
|
16072 + | low_ref: 100000009,
|
16073 + | },
|
16074 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16075 + | condition_index: 20,
|
16076 + | high_ref: 144,
|
16077 + | low_ref: 145,
|
16078 + | },
|
16079 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16080 + | condition_index: 18,
|
16081 + | high_ref: 146,
|
16082 + | low_ref: 145,
|
16083 + | },
|
16084 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16085 + | condition_index: 17,
|
16086 + | high_ref: 147,
|
16087 + | low_ref: 145,
|
16088 + | },
|
16089 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16090 + | condition_index: 16,
|
16091 + | high_ref: 100000005,
|
16092 + | low_ref: 148,
|
16093 + | },
|
16094 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16095 + | condition_index: 9,
|
16096 + | high_ref: 149,
|
16097 + | low_ref: 100000009,
|
16098 + | },
|
16099 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16100 + | condition_index: 32,
|
16101 + | high_ref: 100000011,
|
16102 + | low_ref: 133,
|
16103 + | },
|
16104 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16105 + | condition_index: 28,
|
16106 + | high_ref: 100000011,
|
16107 + | low_ref: 151,
|
16108 + | },
|
16109 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16110 + | condition_index: 27,
|
16111 + | high_ref: 100000011,
|
16112 + | low_ref: 152,
|
16113 + | },
|
16114 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16115 + | condition_index: 22,
|
16116 + | high_ref: 153,
|
16117 + | low_ref: 100000012,
|
16118 + | },
|
16119 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16120 + | condition_index: 21,
|
16121 + | high_ref: 154,
|
16122 + | low_ref: 100000009,
|
16123 + | },
|
16124 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16125 + | condition_index: 20,
|
16126 + | high_ref: 155,
|
16127 + | low_ref: 145,
|
16128 + | },
|
16129 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16130 + | condition_index: 18,
|
16131 + | high_ref: 156,
|
16132 + | low_ref: 145,
|
16133 + | },
|
16134 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16135 + | condition_index: 17,
|
16136 + | high_ref: 157,
|
16137 + | low_ref: 145,
|
16138 + | },
|
16139 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16140 + | condition_index: 16,
|
16141 + | high_ref: 100000005,
|
16142 + | low_ref: 158,
|
16143 + | },
|
16144 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16145 + | condition_index: 9,
|
16146 + | high_ref: 159,
|
16147 + | low_ref: 100000009,
|
16148 + | },
|
16149 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16150 + | condition_index: 16,
|
16151 + | high_ref: 100000005,
|
16152 + | low_ref: 8,
|
16153 + | },
|
16154 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16155 + | condition_index: 36,
|
16156 + | high_ref: 100000080,
|
16157 + | low_ref: 10,
|
16158 + | },
|
16159 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16160 + | condition_index: 35,
|
16161 + | high_ref: 100000078,
|
16162 + | low_ref: 162,
|
16163 + | },
|
16164 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16165 + | condition_index: 31,
|
16166 + | high_ref: 100000079,
|
16167 + | low_ref: 163,
|
16168 + | },
|
16169 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16170 + | condition_index: 30,
|
16171 + | high_ref: 100000024,
|
16172 + | low_ref: 100000034,
|
16173 + | },
|
16174 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16175 + | condition_index: 71,
|
16176 + | high_ref: 100000052,
|
16177 + | low_ref: 100000043,
|
16178 + | },
|
16179 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16180 + | condition_index: 70,
|
16181 + | high_ref: 166,
|
16182 + | low_ref: 100000044,
|
16183 + | },
|
16184 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16185 + | condition_index: 68,
|
16186 + | high_ref: 167,
|
16187 + | low_ref: 100000057,
|
16188 + | },
|
16189 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16190 + | condition_index: 67,
|
16191 + | high_ref: 168,
|
16192 + | low_ref: 100000045,
|
16193 + | },
|
16194 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16195 + | condition_index: 66,
|
16196 + | high_ref: 169,
|
16197 + | low_ref: 100000046,
|
16198 + | },
|
16199 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16200 + | condition_index: 65,
|
16201 + | high_ref: 100000047,
|
16202 + | low_ref: 170,
|
16203 + | },
|
16204 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16205 + | condition_index: 59,
|
16206 + | high_ref: 171,
|
16207 + | low_ref: 22,
|
16208 + | },
|
16209 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16210 + | condition_index: 58,
|
16211 + | high_ref: 171,
|
16212 + | low_ref: 172,
|
16213 + | },
|
16214 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16215 + | condition_index: 54,
|
16216 + | high_ref: 173,
|
16217 + | low_ref: 26,
|
16218 + | },
|
16219 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16220 + | condition_index: 53,
|
16221 + | high_ref: 100000037,
|
16222 + | low_ref: 174,
|
16223 + | },
|
16224 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16225 + | condition_index: 45,
|
16226 + | high_ref: 15,
|
16227 + | low_ref: 175,
|
16228 + | },
|
16229 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16230 + | condition_index: 43,
|
16231 + | high_ref: 100000035,
|
16232 + | low_ref: 176,
|
16233 + | },
|
16234 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16235 + | condition_index: 42,
|
16236 + | high_ref: 100000049,
|
16237 + | low_ref: 177,
|
16238 + | },
|
16239 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16240 + | condition_index: 41,
|
16241 + | high_ref: 178,
|
16242 + | low_ref: 100000049,
|
16243 + | },
|
16244 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16245 + | condition_index: 40,
|
16246 + | high_ref: 179,
|
16247 + | low_ref: 34,
|
16248 + | },
|
16249 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16250 + | condition_index: 39,
|
16251 + | high_ref: 100000077,
|
16252 + | low_ref: 180,
|
16253 + | },
|
16254 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16255 + | condition_index: 38,
|
16256 + | high_ref: 181,
|
16257 + | low_ref: 100000077,
|
16258 + | },
|
16259 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16260 + | condition_index: 33,
|
16261 + | high_ref: 182,
|
16262 + | low_ref: 162,
|
16263 + | },
|
16264 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16265 + | condition_index: 31,
|
16266 + | high_ref: 183,
|
16267 + | low_ref: 163,
|
16268 + | },
|
16269 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16270 + | condition_index: 21,
|
16271 + | high_ref: 165,
|
16272 + | low_ref: 184,
|
16273 + | },
|
16274 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16275 + | condition_index: 19,
|
16276 + | high_ref: 164,
|
16277 + | low_ref: 185,
|
16278 + | },
|
16279 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16280 + | condition_index: 16,
|
16281 + | high_ref: 100000005,
|
16282 + | low_ref: 186,
|
16283 + | },
|
16284 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16285 + | condition_index: 15,
|
16286 + | high_ref: 161,
|
16287 + | low_ref: 187,
|
16288 + | },
|
16289 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16290 + | condition_index: 14,
|
16291 + | high_ref: 188,
|
16292 + | low_ref: 187,
|
16293 + | },
|
16294 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16295 + | condition_index: 13,
|
16296 + | high_ref: 189,
|
16297 + | low_ref: 187,
|
16298 + | },
|
16299 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16300 + | condition_index: 12,
|
16301 + | high_ref: 190,
|
16302 + | low_ref: 187,
|
16303 + | },
|
16304 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16305 + | condition_index: 11,
|
16306 + | high_ref: 191,
|
16307 + | low_ref: 187,
|
16308 + | },
|
16309 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16310 + | condition_index: 9,
|
16311 + | high_ref: 192,
|
16312 + | low_ref: 64,
|
16313 + | },
|
16314 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16315 + | condition_index: 8,
|
16316 + | high_ref: 160,
|
16317 + | low_ref: 193,
|
16318 + | },
|
16319 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16320 + | condition_index: 7,
|
16321 + | high_ref: 150,
|
16322 + | low_ref: 194,
|
16323 + | },
|
16324 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16325 + | condition_index: 44,
|
16326 + | high_ref: 100000090,
|
16327 + | low_ref: 100000034,
|
16328 + | },
|
16329 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16330 + | condition_index: 37,
|
16331 + | high_ref: 9,
|
16332 + | low_ref: 196,
|
16333 + | },
|
16334 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16335 + | condition_index: 24,
|
16336 + | high_ref: 100000014,
|
16337 + | low_ref: 197,
|
16338 + | },
|
16339 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16340 + | condition_index: 20,
|
16341 + | high_ref: 198,
|
16342 + | low_ref: 197,
|
16343 + | },
|
16344 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16345 + | condition_index: 18,
|
16346 + | high_ref: 199,
|
16347 + | low_ref: 197,
|
16348 + | },
|
16349 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16350 + | condition_index: 17,
|
16351 + | high_ref: 200,
|
16352 + | low_ref: 197,
|
16353 + | },
|
16354 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16355 + | condition_index: 16,
|
16356 + | high_ref: 100000005,
|
16357 + | low_ref: 201,
|
16358 + | },
|
16359 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16360 + | condition_index: 9,
|
16361 + | high_ref: 202,
|
16362 + | low_ref: 100000096,
|
16363 + | },
|
16364 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16365 + | condition_index: 6,
|
16366 + | high_ref: 195,
|
16367 + | low_ref: 203,
|
16368 + | },
|
16369 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16370 + | condition_index: 44,
|
16371 + | high_ref: 100000088,
|
16372 + | low_ref: 100000034,
|
16373 + | },
|
16374 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16375 + | condition_index: 37,
|
16376 + | high_ref: 205,
|
16377 + | low_ref: 100000096,
|
16378 + | },
|
16379 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16380 + | condition_index: 36,
|
16381 + | high_ref: 100000081,
|
16382 + | low_ref: 206,
|
16383 + | },
|
16384 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16385 + | condition_index: 35,
|
16386 + | high_ref: 100000078,
|
16387 + | low_ref: 207,
|
16388 + | },
|
16389 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16390 + | condition_index: 31,
|
16391 + | high_ref: 100000079,
|
16392 + | low_ref: 208,
|
16393 + | },
|
16394 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16395 + | condition_index: 30,
|
16396 + | high_ref: 100000025,
|
16397 + | low_ref: 100000034,
|
16398 + | },
|
16399 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16400 + | condition_index: 71,
|
16401 + | high_ref: 100000041,
|
16402 + | low_ref: 100000043,
|
16403 + | },
|
16404 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16405 + | condition_index: 70,
|
16406 + | high_ref: 211,
|
16407 + | low_ref: 100000044,
|
16408 + | },
|
16409 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16410 + | condition_index: 69,
|
16411 + | high_ref: 100000039,
|
16412 + | low_ref: 212,
|
16413 + | },
|
16414 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16415 + | condition_index: 67,
|
16416 + | high_ref: 213,
|
16417 + | low_ref: 100000045,
|
16418 + | },
|
16419 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16420 + | condition_index: 66,
|
16421 + | high_ref: 214,
|
16422 + | low_ref: 100000046,
|
16423 + | },
|
16424 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16425 + | condition_index: 65,
|
16426 + | high_ref: 100000047,
|
16427 + | low_ref: 215,
|
16428 + | },
|
16429 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16430 + | condition_index: 59,
|
16431 + | high_ref: 216,
|
16432 + | low_ref: 22,
|
16433 + | },
|
16434 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16435 + | condition_index: 58,
|
16436 + | high_ref: 216,
|
16437 + | low_ref: 217,
|
16438 + | },
|
16439 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16440 + | condition_index: 54,
|
16441 + | high_ref: 218,
|
16442 + | low_ref: 26,
|
16443 + | },
|
16444 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16445 + | condition_index: 53,
|
16446 + | high_ref: 100000037,
|
16447 + | low_ref: 219,
|
16448 + | },
|
16449 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16450 + | condition_index: 45,
|
16451 + | high_ref: 100000048,
|
16452 + | low_ref: 220,
|
16453 + | },
|
16454 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16455 + | condition_index: 73,
|
16456 + | high_ref: 100000059,
|
16457 + | low_ref: 100000064,
|
16458 + | },
|
16459 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16460 + | condition_index: 71,
|
16461 + | high_ref: 100000053,
|
16462 + | low_ref: 100000043,
|
16463 + | },
|
16464 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16465 + | condition_index: 70,
|
16466 + | high_ref: 223,
|
16467 + | low_ref: 100000044,
|
16468 + | },
|
16469 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16470 + | condition_index: 68,
|
16471 + | high_ref: 224,
|
16472 + | low_ref: 100000057,
|
16473 + | },
|
16474 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16475 + | condition_index: 67,
|
16476 + | high_ref: 225,
|
16477 + | low_ref: 100000045,
|
16478 + | },
|
16479 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16480 + | condition_index: 66,
|
16481 + | high_ref: 226,
|
16482 + | low_ref: 100000046,
|
16483 + | },
|
16484 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16485 + | condition_index: 65,
|
16486 + | high_ref: 100000047,
|
16487 + | low_ref: 227,
|
16488 + | },
|
16489 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16490 + | condition_index: 59,
|
16491 + | high_ref: 228,
|
16492 + | low_ref: 22,
|
16493 + | },
|
16494 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16495 + | condition_index: 58,
|
16496 + | high_ref: 228,
|
16497 + | low_ref: 229,
|
16498 + | },
|
16499 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16500 + | condition_index: 54,
|
16501 + | high_ref: 230,
|
16502 + | low_ref: 26,
|
16503 + | },
|
16504 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16505 + | condition_index: 53,
|
16506 + | high_ref: 100000037,
|
16507 + | low_ref: 231,
|
16508 + | },
|
16509 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16510 + | condition_index: 45,
|
16511 + | high_ref: 222,
|
16512 + | low_ref: 232,
|
16513 + | },
|
16514 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16515 + | condition_index: 43,
|
16516 + | high_ref: 221,
|
16517 + | low_ref: 233,
|
16518 + | },
|
16519 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16520 + | condition_index: 42,
|
16521 + | high_ref: 100000049,
|
16522 + | low_ref: 234,
|
16523 + | },
|
16524 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16525 + | condition_index: 41,
|
16526 + | high_ref: 235,
|
16527 + | low_ref: 100000049,
|
16528 + | },
|
16529 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16530 + | condition_index: 52,
|
16531 + | high_ref: 100000066,
|
16532 + | low_ref: 100000076,
|
16533 + | },
|
16534 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16535 + | condition_index: 43,
|
16536 + | high_ref: 100000050,
|
16537 + | low_ref: 237,
|
16538 + | },
|
16539 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16540 + | condition_index: 40,
|
16541 + | high_ref: 236,
|
16542 + | low_ref: 238,
|
16543 + | },
|
16544 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16545 + | condition_index: 39,
|
16546 + | high_ref: 100000077,
|
16547 + | low_ref: 239,
|
16548 + | },
|
16549 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16550 + | condition_index: 38,
|
16551 + | high_ref: 240,
|
16552 + | low_ref: 100000077,
|
16553 + | },
|
16554 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16555 + | condition_index: 33,
|
16556 + | high_ref: 241,
|
16557 + | low_ref: 207,
|
16558 + | },
|
16559 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16560 + | condition_index: 31,
|
16561 + | high_ref: 242,
|
16562 + | low_ref: 208,
|
16563 + | },
|
16564 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16565 + | condition_index: 21,
|
16566 + | high_ref: 210,
|
16567 + | low_ref: 243,
|
16568 + | },
|
16569 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16570 + | condition_index: 19,
|
16571 + | high_ref: 209,
|
16572 + | low_ref: 244,
|
16573 + | },
|
16574 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16575 + | condition_index: 16,
|
16576 + | high_ref: 100000005,
|
16577 + | low_ref: 245,
|
16578 + | },
|
16579 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16580 + | condition_index: 15,
|
16581 + | high_ref: 161,
|
16582 + | low_ref: 246,
|
16583 + | },
|
16584 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16585 + | condition_index: 14,
|
16586 + | high_ref: 247,
|
16587 + | low_ref: 246,
|
16588 + | },
|
16589 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16590 + | condition_index: 13,
|
16591 + | high_ref: 248,
|
16592 + | low_ref: 246,
|
16593 + | },
|
16594 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16595 + | condition_index: 12,
|
16596 + | high_ref: 249,
|
16597 + | low_ref: 246,
|
16598 + | },
|
16599 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16600 + | condition_index: 11,
|
16601 + | high_ref: 250,
|
16602 + | low_ref: 246,
|
16603 + | },
|
16604 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16605 + | condition_index: 45,
|
16606 + | high_ref: 100000048,
|
16607 + | low_ref: 54,
|
16608 + | },
|
16609 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16610 + | condition_index: 45,
|
16611 + | high_ref: 222,
|
16612 + | low_ref: 54,
|
16613 + | },
|
16614 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16615 + | condition_index: 43,
|
16616 + | high_ref: 252,
|
16617 + | low_ref: 253,
|
16618 + | },
|
16619 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16620 + | condition_index: 42,
|
16621 + | high_ref: 100000049,
|
16622 + | low_ref: 254,
|
16623 + | },
|
16624 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16625 + | condition_index: 41,
|
16626 + | high_ref: 255,
|
16627 + | low_ref: 100000049,
|
16628 + | },
|
16629 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16630 + | condition_index: 40,
|
16631 + | high_ref: 256,
|
16632 + | low_ref: 238,
|
16633 + | },
|
16634 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16635 + | condition_index: 39,
|
16636 + | high_ref: 100000077,
|
16637 + | low_ref: 257,
|
16638 + | },
|
16639 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16640 + | condition_index: 38,
|
16641 + | high_ref: 258,
|
16642 + | low_ref: 100000077,
|
16643 + | },
|
16644 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16645 + | condition_index: 33,
|
16646 + | high_ref: 259,
|
16647 + | low_ref: 100000096,
|
16648 + | },
|
16649 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16650 + | condition_index: 31,
|
16651 + | high_ref: 260,
|
16652 + | low_ref: 52,
|
16653 + | },
|
16654 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16655 + | condition_index: 19,
|
16656 + | high_ref: 53,
|
16657 + | low_ref: 261,
|
16658 + | },
|
16659 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16660 + | condition_index: 9,
|
16661 + | high_ref: 251,
|
16662 + | low_ref: 262,
|
16663 + | },
|
16664 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16665 + | condition_index: 8,
|
16666 + | high_ref: 160,
|
16667 + | low_ref: 263,
|
16668 + | },
|
16669 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16670 + | condition_index: 7,
|
16671 + | high_ref: 150,
|
16672 + | low_ref: 264,
|
16673 + | },
|
16674 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16675 + | condition_index: 44,
|
16676 + | high_ref: 100000091,
|
16677 + | low_ref: 100000034,
|
16678 + | },
|
16679 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16680 + | condition_index: 37,
|
16681 + | high_ref: 205,
|
16682 + | low_ref: 266,
|
16683 + | },
|
16684 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16685 + | condition_index: 24,
|
16686 + | high_ref: 100000014,
|
16687 + | low_ref: 267,
|
16688 + | },
|
16689 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16690 + | condition_index: 20,
|
16691 + | high_ref: 268,
|
16692 + | low_ref: 267,
|
16693 + | },
|
16694 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16695 + | condition_index: 18,
|
16696 + | high_ref: 269,
|
16697 + | low_ref: 267,
|
16698 + | },
|
16699 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16700 + | condition_index: 17,
|
16701 + | high_ref: 270,
|
16702 + | low_ref: 267,
|
16703 + | },
|
16704 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16705 + | condition_index: 16,
|
16706 + | high_ref: 100000005,
|
16707 + | low_ref: 271,
|
16708 + | },
|
16709 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16710 + | condition_index: 9,
|
16711 + | high_ref: 272,
|
16712 + | low_ref: 100000096,
|
16713 + | },
|
16714 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16715 + | condition_index: 6,
|
16716 + | high_ref: 265,
|
16717 + | low_ref: 273,
|
16718 + | },
|
16719 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16720 + | condition_index: 5,
|
16721 + | high_ref: 204,
|
16722 + | low_ref: 274,
|
16723 + | },
|
16724 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16725 + | condition_index: 4,
|
16726 + | high_ref: 131,
|
16727 + | low_ref: 275,
|
16728 + | },
|
16729 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16730 + | condition_index: 36,
|
16731 + | high_ref: 100000007,
|
16732 + | low_ref: 100000008,
|
16733 + | },
|
16734 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16735 + | condition_index: 34,
|
16736 + | high_ref: 277,
|
16737 + | low_ref: 100000008,
|
16738 + | },
|
16739 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16740 + | condition_index: 36,
|
16741 + | high_ref: 100000007,
|
16742 + | low_ref: 100000009,
|
16743 + | },
|
16744 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16745 + | condition_index: 34,
|
16746 + | high_ref: 279,
|
16747 + | low_ref: 100000009,
|
16748 + | },
|
16749 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16750 + | condition_index: 21,
|
16751 + | high_ref: 278,
|
16752 + | low_ref: 280,
|
16753 + | },
|
16754 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16755 + | condition_index: 20,
|
16756 + | high_ref: 281,
|
16757 + | low_ref: 100000009,
|
16758 + | },
|
16759 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16760 + | condition_index: 22,
|
16761 + | high_ref: 136,
|
16762 + | low_ref: 100000012,
|
16763 + | },
|
16764 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16765 + | condition_index: 21,
|
16766 + | high_ref: 283,
|
16767 + | low_ref: 100000009,
|
16768 + | },
|
16769 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16770 + | condition_index: 20,
|
16771 + | high_ref: 284,
|
16772 + | low_ref: 145,
|
16773 + | },
|
16774 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16775 + | condition_index: 18,
|
16776 + | high_ref: 285,
|
16777 + | low_ref: 145,
|
16778 + | },
|
16779 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16780 + | condition_index: 17,
|
16781 + | high_ref: 286,
|
16782 + | low_ref: 145,
|
16783 + | },
|
16784 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16785 + | condition_index: 10,
|
16786 + | high_ref: 282,
|
16787 + | low_ref: 287,
|
16788 + | },
|
16789 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16790 + | condition_index: 10,
|
16791 + | high_ref: 282,
|
16792 + | low_ref: 100000009,
|
16793 + | },
|
16794 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16795 + | condition_index: 9,
|
16796 + | high_ref: 288,
|
16797 + | low_ref: 289,
|
16798 + | },
|
16799 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16800 + | condition_index: 10,
|
16801 + | high_ref: 282,
|
16802 + | low_ref: 158,
|
16803 + | },
|
16804 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16805 + | condition_index: 9,
|
16806 + | high_ref: 291,
|
16807 + | low_ref: 289,
|
16808 + | },
|
16809 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16810 + | condition_index: 55,
|
16811 + | high_ref: 100000018,
|
16812 + | low_ref: 100000020,
|
16813 + | },
|
16814 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16815 + | condition_index: 46,
|
16816 + | high_ref: 100000016,
|
16817 + | low_ref: 293,
|
16818 + | },
|
16819 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16820 + | condition_index: 25,
|
16821 + | high_ref: 294,
|
16822 + | low_ref: 6,
|
16823 + | },
|
16824 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16825 + | condition_index: 23,
|
16826 + | high_ref: 295,
|
16827 + | low_ref: 100000021,
|
16828 + | },
|
16829 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16830 + | condition_index: 44,
|
16831 + | high_ref: 100000087,
|
16832 + | low_ref: 100000034,
|
16833 + | },
|
16834 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16835 + | condition_index: 37,
|
16836 + | high_ref: 297,
|
16837 + | low_ref: 100000096,
|
16838 + | },
|
16839 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16840 + | condition_index: 36,
|
16841 + | high_ref: 100000083,
|
16842 + | low_ref: 298,
|
16843 + | },
|
16844 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16845 + | condition_index: 35,
|
16846 + | high_ref: 100000078,
|
16847 + | low_ref: 299,
|
16848 + | },
|
16849 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16850 + | condition_index: 31,
|
16851 + | high_ref: 100000079,
|
16852 + | low_ref: 300,
|
16853 + | },
|
16854 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16855 + | condition_index: 34,
|
16856 + | high_ref: 100000029,
|
16857 + | low_ref: 100000030,
|
16858 + | },
|
16859 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16860 + | condition_index: 30,
|
16861 + | high_ref: 302,
|
16862 + | low_ref: 100000034,
|
16863 + | },
|
16864 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16865 + | condition_index: 30,
|
16866 + | high_ref: 100000030,
|
16867 + | low_ref: 100000034,
|
16868 + | },
|
16869 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16870 + | condition_index: 71,
|
16871 + | high_ref: 100000040,
|
16872 + | low_ref: 100000043,
|
16873 + | },
|
16874 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16875 + | condition_index: 70,
|
16876 + | high_ref: 305,
|
16877 + | low_ref: 100000044,
|
16878 + | },
|
16879 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16880 + | condition_index: 69,
|
16881 + | high_ref: 100000039,
|
16882 + | low_ref: 306,
|
16883 + | },
|
16884 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16885 + | condition_index: 67,
|
16886 + | high_ref: 307,
|
16887 + | low_ref: 100000045,
|
16888 + | },
|
16889 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16890 + | condition_index: 66,
|
16891 + | high_ref: 308,
|
16892 + | low_ref: 100000046,
|
16893 + | },
|
16894 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16895 + | condition_index: 65,
|
16896 + | high_ref: 100000047,
|
16897 + | low_ref: 309,
|
16898 + | },
|
16899 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16900 + | condition_index: 59,
|
16901 + | high_ref: 310,
|
16902 + | low_ref: 22,
|
16903 + | },
|
16904 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16905 + | condition_index: 58,
|
16906 + | high_ref: 310,
|
16907 + | low_ref: 311,
|
16908 + | },
|
16909 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16910 + | condition_index: 54,
|
16911 + | high_ref: 312,
|
16912 + | low_ref: 26,
|
16913 + | },
|
16914 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16915 + | condition_index: 53,
|
16916 + | high_ref: 100000037,
|
16917 + | low_ref: 313,
|
16918 + | },
|
16919 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16920 + | condition_index: 45,
|
16921 + | high_ref: 100000048,
|
16922 + | low_ref: 314,
|
16923 + | },
|
16924 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16925 + | condition_index: 73,
|
16926 + | high_ref: 100000061,
|
16927 + | low_ref: 100000064,
|
16928 + | },
|
16929 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16930 + | condition_index: 74,
|
16931 + | high_ref: 100000062,
|
16932 + | low_ref: 100000063,
|
16933 + | },
|
16934 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16935 + | condition_index: 73,
|
16936 + | high_ref: 317,
|
16937 + | low_ref: 100000064,
|
16938 + | },
|
16939 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16940 + | condition_index: 62,
|
16941 + | high_ref: 316,
|
16942 + | low_ref: 318,
|
16943 + | },
|
16944 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16945 + | condition_index: 71,
|
16946 + | high_ref: 100000055,
|
16947 + | low_ref: 100000043,
|
16948 + | },
|
16949 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16950 + | condition_index: 70,
|
16951 + | high_ref: 320,
|
16952 + | low_ref: 100000044,
|
16953 + | },
|
16954 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16955 + | condition_index: 68,
|
16956 + | high_ref: 321,
|
16957 + | low_ref: 100000057,
|
16958 + | },
|
16959 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16960 + | condition_index: 67,
|
16961 + | high_ref: 322,
|
16962 + | low_ref: 100000045,
|
16963 + | },
|
16964 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16965 + | condition_index: 66,
|
16966 + | high_ref: 323,
|
16967 + | low_ref: 100000046,
|
16968 + | },
|
16969 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16970 + | condition_index: 65,
|
16971 + | high_ref: 100000047,
|
16972 + | low_ref: 324,
|
16973 + | },
|
16974 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16975 + | condition_index: 59,
|
16976 + | high_ref: 325,
|
16977 + | low_ref: 22,
|
16978 + | },
|
16979 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16980 + | condition_index: 58,
|
16981 + | high_ref: 325,
|
16982 + | low_ref: 326,
|
16983 + | },
|
16984 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16985 + | condition_index: 54,
|
16986 + | high_ref: 327,
|
16987 + | low_ref: 26,
|
16988 + | },
|
16989 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16990 + | condition_index: 53,
|
16991 + | high_ref: 100000037,
|
16992 + | low_ref: 328,
|
16993 + | },
|
16994 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
16995 + | condition_index: 45,
|
16996 + | high_ref: 319,
|
16997 + | low_ref: 329,
|
16998 + | },
|
16999 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17000 + | condition_index: 43,
|
17001 + | high_ref: 315,
|
17002 + | low_ref: 330,
|
17003 + | },
|
17004 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17005 + | condition_index: 42,
|
17006 + | high_ref: 100000049,
|
17007 + | low_ref: 331,
|
17008 + | },
|
17009 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17010 + | condition_index: 41,
|
17011 + | high_ref: 332,
|
17012 + | low_ref: 100000049,
|
17013 + | },
|
17014 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17015 + | condition_index: 75,
|
17016 + | high_ref: 100000069,
|
17017 + | low_ref: 100000071,
|
17018 + | },
|
17019 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17020 + | condition_index: 72,
|
17021 + | high_ref: 334,
|
17022 + | low_ref: 100000072,
|
17023 + | },
|
17024 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17025 + | condition_index: 70,
|
17026 + | high_ref: 335,
|
17027 + | low_ref: 100000044,
|
17028 + | },
|
17029 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17030 + | condition_index: 67,
|
17031 + | high_ref: 336,
|
17032 + | low_ref: 100000045,
|
17033 + | },
|
17034 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17035 + | condition_index: 66,
|
17036 + | high_ref: 337,
|
17037 + | low_ref: 100000046,
|
17038 + | },
|
17039 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17040 + | condition_index: 70,
|
17041 + | high_ref: 100000073,
|
17042 + | low_ref: 100000044,
|
17043 + | },
|
17044 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17045 + | condition_index: 67,
|
17046 + | high_ref: 339,
|
17047 + | low_ref: 100000045,
|
17048 + | },
|
17049 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17050 + | condition_index: 66,
|
17051 + | high_ref: 340,
|
17052 + | low_ref: 100000046,
|
17053 + | },
|
17054 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17055 + | condition_index: 65,
|
17056 + | high_ref: 338,
|
17057 + | low_ref: 341,
|
17058 + | },
|
17059 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17060 + | condition_index: 64,
|
17061 + | high_ref: 342,
|
17062 + | low_ref: 100000074,
|
17063 + | },
|
17064 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17065 + | condition_index: 64,
|
17066 + | high_ref: 100000038,
|
17067 + | low_ref: 100000074,
|
17068 + | },
|
17069 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17070 + | condition_index: 59,
|
17071 + | high_ref: 343,
|
17072 + | low_ref: 344,
|
17073 + | },
|
17074 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17075 + | condition_index: 58,
|
17076 + | high_ref: 343,
|
17077 + | low_ref: 345,
|
17078 + | },
|
17079 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17080 + | condition_index: 57,
|
17081 + | high_ref: 346,
|
17082 + | low_ref: 100000075,
|
17083 + | },
|
17084 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17085 + | condition_index: 56,
|
17086 + | high_ref: 100000068,
|
17087 + | low_ref: 347,
|
17088 + | },
|
17089 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17090 + | condition_index: 59,
|
17091 + | high_ref: 100000074,
|
17092 + | low_ref: 344,
|
17093 + | },
|
17094 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17095 + | condition_index: 58,
|
17096 + | high_ref: 100000074,
|
17097 + | low_ref: 349,
|
17098 + | },
|
17099 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17100 + | condition_index: 57,
|
17101 + | high_ref: 350,
|
17102 + | low_ref: 100000075,
|
17103 + | },
|
17104 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17105 + | condition_index: 56,
|
17106 + | high_ref: 100000068,
|
17107 + | low_ref: 351,
|
17108 + | },
|
17109 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17110 + | condition_index: 54,
|
17111 + | high_ref: 348,
|
17112 + | low_ref: 352,
|
17113 + | },
|
17114 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17115 + | condition_index: 52,
|
17116 + | high_ref: 353,
|
17117 + | low_ref: 100000076,
|
17118 + | },
|
17119 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17120 + | condition_index: 43,
|
17121 + | high_ref: 100000050,
|
17122 + | low_ref: 354,
|
17123 + | },
|
17124 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17125 + | condition_index: 40,
|
17126 + | high_ref: 333,
|
17127 + | low_ref: 355,
|
17128 + | },
|
17129 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17130 + | condition_index: 39,
|
17131 + | high_ref: 100000077,
|
17132 + | low_ref: 356,
|
17133 + | },
|
17134 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17135 + | condition_index: 38,
|
17136 + | high_ref: 357,
|
17137 + | low_ref: 100000077,
|
17138 + | },
|
17139 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17140 + | condition_index: 33,
|
17141 + | high_ref: 358,
|
17142 + | low_ref: 299,
|
17143 + | },
|
17144 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17145 + | condition_index: 31,
|
17146 + | high_ref: 359,
|
17147 + | low_ref: 300,
|
17148 + | },
|
17149 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17150 + | condition_index: 29,
|
17151 + | high_ref: 304,
|
17152 + | low_ref: 360,
|
17153 + | },
|
17154 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17155 + | condition_index: 26,
|
17156 + | high_ref: 361,
|
17157 + | low_ref: 360,
|
17158 + | },
|
17159 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17160 + | condition_index: 21,
|
17161 + | high_ref: 303,
|
17162 + | low_ref: 362,
|
17163 + | },
|
17164 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17165 + | condition_index: 19,
|
17166 + | high_ref: 301,
|
17167 + | low_ref: 363,
|
17168 + | },
|
17169 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17170 + | condition_index: 15,
|
17171 + | high_ref: 296,
|
17172 + | low_ref: 364,
|
17173 + | },
|
17174 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17175 + | condition_index: 14,
|
17176 + | high_ref: 365,
|
17177 + | low_ref: 364,
|
17178 + | },
|
17179 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17180 + | condition_index: 13,
|
17181 + | high_ref: 366,
|
17182 + | low_ref: 364,
|
17183 + | },
|
17184 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17185 + | condition_index: 12,
|
17186 + | high_ref: 367,
|
17187 + | low_ref: 364,
|
17188 + | },
|
17189 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17190 + | condition_index: 11,
|
17191 + | high_ref: 368,
|
17192 + | low_ref: 364,
|
17193 + | },
|
17194 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17195 + | condition_index: 23,
|
17196 + | high_ref: 6,
|
17197 + | low_ref: 100000021,
|
17198 + | },
|
17199 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17200 + | condition_index: 15,
|
17201 + | high_ref: 370,
|
17202 + | low_ref: 100000022,
|
17203 + | },
|
17204 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17205 + | condition_index: 14,
|
17206 + | high_ref: 371,
|
17207 + | low_ref: 100000022,
|
17208 + | },
|
17209 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17210 + | condition_index: 13,
|
17211 + | high_ref: 372,
|
17212 + | low_ref: 100000022,
|
17213 + | },
|
17214 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17215 + | condition_index: 12,
|
17216 + | high_ref: 373,
|
17217 + | low_ref: 100000022,
|
17218 + | },
|
17219 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17220 + | condition_index: 11,
|
17221 + | high_ref: 374,
|
17222 + | low_ref: 100000022,
|
17223 + | },
|
17224 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17225 + | condition_index: 10,
|
17226 + | high_ref: 369,
|
17227 + | low_ref: 375,
|
17228 + | },
|
17229 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17230 + | condition_index: 62,
|
17231 + | high_ref: 316,
|
17232 + | low_ref: 100000064,
|
17233 + | },
|
17234 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17235 + | condition_index: 45,
|
17236 + | high_ref: 377,
|
17237 + | low_ref: 54,
|
17238 + | },
|
17239 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17240 + | condition_index: 43,
|
17241 + | high_ref: 252,
|
17242 + | low_ref: 378,
|
17243 + | },
|
17244 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17245 + | condition_index: 42,
|
17246 + | high_ref: 100000049,
|
17247 + | low_ref: 379,
|
17248 + | },
|
17249 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17250 + | condition_index: 41,
|
17251 + | high_ref: 380,
|
17252 + | low_ref: 100000049,
|
17253 + | },
|
17254 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17255 + | condition_index: 52,
|
17256 + | high_ref: 352,
|
17257 + | low_ref: 100000076,
|
17258 + | },
|
17259 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17260 + | condition_index: 43,
|
17261 + | high_ref: 100000050,
|
17262 + | low_ref: 382,
|
17263 + | },
|
17264 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17265 + | condition_index: 40,
|
17266 + | high_ref: 381,
|
17267 + | low_ref: 383,
|
17268 + | },
|
17269 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17270 + | condition_index: 39,
|
17271 + | high_ref: 100000077,
|
17272 + | low_ref: 384,
|
17273 + | },
|
17274 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17275 + | condition_index: 38,
|
17276 + | high_ref: 385,
|
17277 + | low_ref: 100000077,
|
17278 + | },
|
17279 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17280 + | condition_index: 33,
|
17281 + | high_ref: 386,
|
17282 + | low_ref: 100000096,
|
17283 + | },
|
17284 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17285 + | condition_index: 31,
|
17286 + | high_ref: 387,
|
17287 + | low_ref: 52,
|
17288 + | },
|
17289 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17290 + | condition_index: 19,
|
17291 + | high_ref: 53,
|
17292 + | low_ref: 388,
|
17293 + | },
|
17294 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17295 + | condition_index: 10,
|
17296 + | high_ref: 389,
|
17297 + | low_ref: 100000022,
|
17298 + | },
|
17299 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17300 + | condition_index: 9,
|
17301 + | high_ref: 376,
|
17302 + | low_ref: 390,
|
17303 + | },
|
17304 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17305 + | condition_index: 8,
|
17306 + | high_ref: 292,
|
17307 + | low_ref: 391,
|
17308 + | },
|
17309 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17310 + | condition_index: 7,
|
17311 + | high_ref: 290,
|
17312 + | low_ref: 392,
|
17313 + | },
|
17314 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17315 + | condition_index: 44,
|
17316 + | high_ref: 100000093,
|
17317 + | low_ref: 100000034,
|
17318 + | },
|
17319 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17320 + | condition_index: 37,
|
17321 + | high_ref: 297,
|
17322 + | low_ref: 394,
|
17323 + | },
|
17324 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17325 + | condition_index: 24,
|
17326 + | high_ref: 100000013,
|
17327 + | low_ref: 395,
|
17328 + | },
|
17329 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17330 + | condition_index: 20,
|
17331 + | high_ref: 396,
|
17332 + | low_ref: 395,
|
17333 + | },
|
17334 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17335 + | condition_index: 44,
|
17336 + | high_ref: 100000089,
|
17337 + | low_ref: 100000034,
|
17338 + | },
|
17339 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17340 + | condition_index: 37,
|
17341 + | high_ref: 398,
|
17342 + | low_ref: 100000034,
|
17343 + | },
|
17344 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17345 + | condition_index: 24,
|
17346 + | high_ref: 100000014,
|
17347 + | low_ref: 399,
|
17348 + | },
|
17349 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17350 + | condition_index: 20,
|
17351 + | high_ref: 400,
|
17352 + | low_ref: 399,
|
17353 + | },
|
17354 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17355 + | condition_index: 18,
|
17356 + | high_ref: 401,
|
17357 + | low_ref: 399,
|
17358 + | },
|
17359 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17360 + | condition_index: 17,
|
17361 + | high_ref: 402,
|
17362 + | low_ref: 399,
|
17363 + | },
|
17364 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17365 + | condition_index: 10,
|
17366 + | high_ref: 397,
|
17367 + | low_ref: 403,
|
17368 + | },
|
17369 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17370 + | condition_index: 9,
|
17371 + | high_ref: 404,
|
17372 + | low_ref: 100000096,
|
17373 + | },
|
17374 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17375 + | condition_index: 6,
|
17376 + | high_ref: 393,
|
17377 + | low_ref: 405,
|
17378 + | },
|
17379 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17380 + | condition_index: 5,
|
17381 + | high_ref: 100000002,
|
17382 + | low_ref: 406,
|
17383 + | },
|
17384 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17385 + | condition_index: 9,
|
17386 + | high_ref: 148,
|
17387 + | low_ref: 100000009,
|
17388 + | },
|
17389 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17390 + | condition_index: 9,
|
17391 + | high_ref: 158,
|
17392 + | low_ref: 100000009,
|
17393 + | },
|
17394 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17395 + | condition_index: 36,
|
17396 + | high_ref: 100000082,
|
17397 + | low_ref: 10,
|
17398 + | },
|
17399 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17400 + | condition_index: 35,
|
17401 + | high_ref: 100000078,
|
17402 + | low_ref: 410,
|
17403 + | },
|
17404 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17405 + | condition_index: 31,
|
17406 + | high_ref: 100000079,
|
17407 + | low_ref: 411,
|
17408 + | },
|
17409 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17410 + | condition_index: 30,
|
17411 + | high_ref: 100000028,
|
17412 + | low_ref: 100000034,
|
17413 + | },
|
17414 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17415 + | condition_index: 71,
|
17416 + | high_ref: 100000054,
|
17417 + | low_ref: 100000043,
|
17418 + | },
|
17419 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17420 + | condition_index: 70,
|
17421 + | high_ref: 414,
|
17422 + | low_ref: 100000044,
|
17423 + | },
|
17424 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17425 + | condition_index: 68,
|
17426 + | high_ref: 415,
|
17427 + | low_ref: 100000057,
|
17428 + | },
|
17429 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17430 + | condition_index: 67,
|
17431 + | high_ref: 416,
|
17432 + | low_ref: 100000045,
|
17433 + | },
|
17434 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17435 + | condition_index: 66,
|
17436 + | high_ref: 417,
|
17437 + | low_ref: 100000046,
|
17438 + | },
|
17439 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17440 + | condition_index: 65,
|
17441 + | high_ref: 100000047,
|
17442 + | low_ref: 418,
|
17443 + | },
|
17444 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17445 + | condition_index: 59,
|
17446 + | high_ref: 419,
|
17447 + | low_ref: 22,
|
17448 + | },
|
17449 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17450 + | condition_index: 58,
|
17451 + | high_ref: 419,
|
17452 + | low_ref: 420,
|
17453 + | },
|
17454 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17455 + | condition_index: 54,
|
17456 + | high_ref: 421,
|
17457 + | low_ref: 26,
|
17458 + | },
|
17459 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17460 + | condition_index: 53,
|
17461 + | high_ref: 100000037,
|
17462 + | low_ref: 422,
|
17463 + | },
|
17464 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17465 + | condition_index: 45,
|
17466 + | high_ref: 15,
|
17467 + | low_ref: 423,
|
17468 + | },
|
17469 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17470 + | condition_index: 43,
|
17471 + | high_ref: 100000035,
|
17472 + | low_ref: 424,
|
17473 + | },
|
17474 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17475 + | condition_index: 42,
|
17476 + | high_ref: 100000049,
|
17477 + | low_ref: 425,
|
17478 + | },
|
17479 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17480 + | condition_index: 41,
|
17481 + | high_ref: 426,
|
17482 + | low_ref: 100000049,
|
17483 + | },
|
17484 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17485 + | condition_index: 40,
|
17486 + | high_ref: 427,
|
17487 + | low_ref: 34,
|
17488 + | },
|
17489 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17490 + | condition_index: 39,
|
17491 + | high_ref: 100000077,
|
17492 + | low_ref: 428,
|
17493 + | },
|
17494 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17495 + | condition_index: 38,
|
17496 + | high_ref: 429,
|
17497 + | low_ref: 100000077,
|
17498 + | },
|
17499 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17500 + | condition_index: 33,
|
17501 + | high_ref: 430,
|
17502 + | low_ref: 410,
|
17503 + | },
|
17504 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17505 + | condition_index: 31,
|
17506 + | high_ref: 431,
|
17507 + | low_ref: 411,
|
17508 + | },
|
17509 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17510 + | condition_index: 21,
|
17511 + | high_ref: 413,
|
17512 + | low_ref: 432,
|
17513 + | },
|
17514 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17515 + | condition_index: 19,
|
17516 + | high_ref: 412,
|
17517 + | low_ref: 433,
|
17518 + | },
|
17519 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17520 + | condition_index: 15,
|
17521 + | high_ref: 8,
|
17522 + | low_ref: 434,
|
17523 + | },
|
17524 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17525 + | condition_index: 14,
|
17526 + | high_ref: 435,
|
17527 + | low_ref: 434,
|
17528 + | },
|
17529 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17530 + | condition_index: 13,
|
17531 + | high_ref: 436,
|
17532 + | low_ref: 434,
|
17533 + | },
|
17534 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17535 + | condition_index: 12,
|
17536 + | high_ref: 437,
|
17537 + | low_ref: 434,
|
17538 + | },
|
17539 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17540 + | condition_index: 11,
|
17541 + | high_ref: 438,
|
17542 + | low_ref: 434,
|
17543 + | },
|
17544 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17545 + | condition_index: 9,
|
17546 + | high_ref: 439,
|
17547 + | low_ref: 64,
|
17548 + | },
|
17549 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17550 + | condition_index: 8,
|
17551 + | high_ref: 409,
|
17552 + | low_ref: 440,
|
17553 + | },
|
17554 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17555 + | condition_index: 7,
|
17556 + | high_ref: 408,
|
17557 + | low_ref: 441,
|
17558 + | },
|
17559 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17560 + | condition_index: 6,
|
17561 + | high_ref: 442,
|
17562 + | low_ref: 74,
|
17563 + | },
|
17564 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17565 + | condition_index: 63,
|
17566 + | high_ref: 100000084,
|
17567 + | low_ref: 100000085,
|
17568 + | },
|
17569 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17570 + | condition_index: 61,
|
17571 + | high_ref: 444,
|
17572 + | low_ref: 100000085,
|
17573 + | },
|
17574 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17575 + | condition_index: 60,
|
17576 + | high_ref: 100000084,
|
17577 + | low_ref: 445,
|
17578 + | },
|
17579 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17580 + | condition_index: 37,
|
17581 + | high_ref: 398,
|
17582 + | low_ref: 100000096,
|
17583 + | },
|
17584 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17585 + | condition_index: 36,
|
17586 + | high_ref: 446,
|
17587 + | low_ref: 447,
|
17588 + | },
|
17589 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17590 + | condition_index: 35,
|
17591 + | high_ref: 100000078,
|
17592 + | low_ref: 448,
|
17593 + | },
|
17594 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17595 + | condition_index: 31,
|
17596 + | high_ref: 100000079,
|
17597 + | low_ref: 449,
|
17598 + | },
|
17599 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17600 + | condition_index: 63,
|
17601 + | high_ref: 100000032,
|
17602 + | low_ref: 100000033,
|
17603 + | },
|
17604 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17605 + | condition_index: 61,
|
17606 + | high_ref: 451,
|
17607 + | low_ref: 100000033,
|
17608 + | },
|
17609 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17610 + | condition_index: 60,
|
17611 + | high_ref: 100000032,
|
17612 + | low_ref: 452,
|
17613 + | },
|
17614 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17615 + | condition_index: 30,
|
17616 + | high_ref: 453,
|
17617 + | low_ref: 100000034,
|
17618 + | },
|
17619 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17620 + | condition_index: 71,
|
17621 + | high_ref: 100000042,
|
17622 + | low_ref: 100000043,
|
17623 + | },
|
17624 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17625 + | condition_index: 70,
|
17626 + | high_ref: 455,
|
17627 + | low_ref: 100000044,
|
17628 + | },
|
17629 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17630 + | condition_index: 69,
|
17631 + | high_ref: 100000039,
|
17632 + | low_ref: 456,
|
17633 + | },
|
17634 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17635 + | condition_index: 67,
|
17636 + | high_ref: 457,
|
17637 + | low_ref: 100000045,
|
17638 + | },
|
17639 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17640 + | condition_index: 66,
|
17641 + | high_ref: 458,
|
17642 + | low_ref: 100000046,
|
17643 + | },
|
17644 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17645 + | condition_index: 65,
|
17646 + | high_ref: 100000047,
|
17647 + | low_ref: 459,
|
17648 + | },
|
17649 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17650 + | condition_index: 59,
|
17651 + | high_ref: 460,
|
17652 + | low_ref: 22,
|
17653 + | },
|
17654 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17655 + | condition_index: 58,
|
17656 + | high_ref: 460,
|
17657 + | low_ref: 461,
|
17658 + | },
|
17659 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17660 + | condition_index: 54,
|
17661 + | high_ref: 462,
|
17662 + | low_ref: 26,
|
17663 + | },
|
17664 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17665 + | condition_index: 53,
|
17666 + | high_ref: 100000037,
|
17667 + | low_ref: 463,
|
17668 + | },
|
17669 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17670 + | condition_index: 45,
|
17671 + | high_ref: 100000048,
|
17672 + | low_ref: 464,
|
17673 + | },
|
17674 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17675 + | condition_index: 71,
|
17676 + | high_ref: 100000056,
|
17677 + | low_ref: 100000043,
|
17678 + | },
|
17679 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17680 + | condition_index: 70,
|
17681 + | high_ref: 466,
|
17682 + | low_ref: 100000044,
|
17683 + | },
|
17684 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17685 + | condition_index: 68,
|
17686 + | high_ref: 467,
|
17687 + | low_ref: 100000057,
|
17688 + | },
|
17689 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17690 + | condition_index: 67,
|
17691 + | high_ref: 468,
|
17692 + | low_ref: 100000045,
|
17693 + | },
|
17694 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17695 + | condition_index: 66,
|
17696 + | high_ref: 469,
|
17697 + | low_ref: 100000046,
|
17698 + | },
|
17699 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17700 + | condition_index: 65,
|
17701 + | high_ref: 100000047,
|
17702 + | low_ref: 470,
|
17703 + | },
|
17704 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17705 + | condition_index: 59,
|
17706 + | high_ref: 471,
|
17707 + | low_ref: 22,
|
17708 + | },
|
17709 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17710 + | condition_index: 58,
|
17711 + | high_ref: 471,
|
17712 + | low_ref: 472,
|
17713 + | },
|
17714 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17715 + | condition_index: 54,
|
17716 + | high_ref: 473,
|
17717 + | low_ref: 26,
|
17718 + | },
|
17719 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17720 + | condition_index: 53,
|
17721 + | high_ref: 100000037,
|
17722 + | low_ref: 474,
|
17723 + | },
|
17724 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17725 + | condition_index: 45,
|
17726 + | high_ref: 319,
|
17727 + | low_ref: 475,
|
17728 + | },
|
17729 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17730 + | condition_index: 43,
|
17731 + | high_ref: 465,
|
17732 + | low_ref: 476,
|
17733 + | },
|
17734 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17735 + | condition_index: 42,
|
17736 + | high_ref: 100000049,
|
17737 + | low_ref: 477,
|
17738 + | },
|
17739 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17740 + | condition_index: 41,
|
17741 + | high_ref: 478,
|
17742 + | low_ref: 100000049,
|
17743 + | },
|
17744 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17745 + | condition_index: 75,
|
17746 + | high_ref: 100000070,
|
17747 + | low_ref: 100000071,
|
17748 + | },
|
17749 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17750 + | condition_index: 72,
|
17751 + | high_ref: 480,
|
17752 + | low_ref: 100000072,
|
17753 + | },
|
17754 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17755 + | condition_index: 70,
|
17756 + | high_ref: 481,
|
17757 + | low_ref: 100000044,
|
17758 + | },
|
17759 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17760 + | condition_index: 67,
|
17761 + | high_ref: 482,
|
17762 + | low_ref: 100000045,
|
17763 + | },
|
17764 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17765 + | condition_index: 66,
|
17766 + | high_ref: 483,
|
17767 + | low_ref: 100000046,
|
17768 + | },
|
17769 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17770 + | condition_index: 65,
|
17771 + | high_ref: 484,
|
17772 + | low_ref: 341,
|
17773 + | },
|
17774 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17775 + | condition_index: 64,
|
17776 + | high_ref: 485,
|
17777 + | low_ref: 100000074,
|
17778 + | },
|
17779 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17780 + | condition_index: 59,
|
17781 + | high_ref: 486,
|
17782 + | low_ref: 344,
|
17783 + | },
|
17784 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17785 + | condition_index: 58,
|
17786 + | high_ref: 486,
|
17787 + | low_ref: 487,
|
17788 + | },
|
17789 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17790 + | condition_index: 57,
|
17791 + | high_ref: 488,
|
17792 + | low_ref: 100000075,
|
17793 + | },
|
17794 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17795 + | condition_index: 56,
|
17796 + | high_ref: 100000068,
|
17797 + | low_ref: 489,
|
17798 + | },
|
17799 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17800 + | condition_index: 54,
|
17801 + | high_ref: 490,
|
17802 + | low_ref: 352,
|
17803 + | },
|
17804 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17805 + | condition_index: 52,
|
17806 + | high_ref: 491,
|
17807 + | low_ref: 100000076,
|
17808 + | },
|
17809 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17810 + | condition_index: 43,
|
17811 + | high_ref: 100000050,
|
17812 + | low_ref: 492,
|
17813 + | },
|
17814 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17815 + | condition_index: 40,
|
17816 + | high_ref: 479,
|
17817 + | low_ref: 493,
|
17818 + | },
|
17819 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17820 + | condition_index: 39,
|
17821 + | high_ref: 100000077,
|
17822 + | low_ref: 494,
|
17823 + | },
|
17824 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17825 + | condition_index: 38,
|
17826 + | high_ref: 495,
|
17827 + | low_ref: 100000077,
|
17828 + | },
|
17829 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17830 + | condition_index: 33,
|
17831 + | high_ref: 496,
|
17832 + | low_ref: 448,
|
17833 + | },
|
17834 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17835 + | condition_index: 31,
|
17836 + | high_ref: 497,
|
17837 + | low_ref: 449,
|
17838 + | },
|
17839 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17840 + | condition_index: 21,
|
17841 + | high_ref: 454,
|
17842 + | low_ref: 498,
|
17843 + | },
|
17844 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17845 + | condition_index: 19,
|
17846 + | high_ref: 450,
|
17847 + | low_ref: 499,
|
17848 + | },
|
17849 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17850 + | condition_index: 15,
|
17851 + | high_ref: 8,
|
17852 + | low_ref: 500,
|
17853 + | },
|
17854 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17855 + | condition_index: 14,
|
17856 + | high_ref: 501,
|
17857 + | low_ref: 500,
|
17858 + | },
|
17859 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17860 + | condition_index: 13,
|
17861 + | high_ref: 502,
|
17862 + | low_ref: 500,
|
17863 + | },
|
17864 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17865 + | condition_index: 12,
|
17866 + | high_ref: 503,
|
17867 + | low_ref: 500,
|
17868 + | },
|
17869 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17870 + | condition_index: 11,
|
17871 + | high_ref: 504,
|
17872 + | low_ref: 500,
|
17873 + | },
|
17874 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17875 + | condition_index: 9,
|
17876 + | high_ref: 505,
|
17877 + | low_ref: 389,
|
17878 + | },
|
17879 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17880 + | condition_index: 8,
|
17881 + | high_ref: 409,
|
17882 + | low_ref: 506,
|
17883 + | },
|
17884 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17885 + | condition_index: 7,
|
17886 + | high_ref: 408,
|
17887 + | low_ref: 507,
|
17888 + | },
|
17889 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17890 + | condition_index: 37,
|
17891 + | high_ref: 398,
|
17892 + | low_ref: 120,
|
17893 + | },
|
17894 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17895 + | condition_index: 24,
|
17896 + | high_ref: 100000014,
|
17897 + | low_ref: 509,
|
17898 + | },
|
17899 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17900 + | condition_index: 20,
|
17901 + | high_ref: 510,
|
17902 + | low_ref: 509,
|
17903 + | },
|
17904 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17905 + | condition_index: 18,
|
17906 + | high_ref: 511,
|
17907 + | low_ref: 509,
|
17908 + | },
|
17909 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17910 + | condition_index: 17,
|
17911 + | high_ref: 512,
|
17912 + | low_ref: 509,
|
17913 + | },
|
17914 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17915 + | condition_index: 9,
|
17916 + | high_ref: 513,
|
17917 + | low_ref: 100000096,
|
17918 + | },
|
17919 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17920 + | condition_index: 6,
|
17921 + | high_ref: 508,
|
17922 + | low_ref: 514,
|
17923 + | },
|
17924 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17925 + | condition_index: 5,
|
17926 + | high_ref: 443,
|
17927 + | low_ref: 515,
|
17928 + | },
|
17929 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17930 + | condition_index: 4,
|
17931 + | high_ref: 407,
|
17932 + | low_ref: 516,
|
17933 + | },
|
17934 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17935 + | condition_index: 3,
|
17936 + | high_ref: 276,
|
17937 + | low_ref: 517,
|
17938 + | },
|
17939 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17940 + | condition_index: 2,
|
17941 + | high_ref: 130,
|
17942 + | low_ref: 518,
|
17943 + | },
|
17944 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17945 + | condition_index: 1,
|
17946 + | high_ref: 519,
|
17947 + | low_ref: 100000096,
|
17948 + | },
|
17949 + | crate::endpoint_lib::bdd_interpreter::BddNode {
|
17950 + | condition_index: 0,
|
17951 + | high_ref: 520,
|
17952 + | low_ref: 100000096,
|
17953 + | },
|
17954 + | ];
|
17955 + | // These are all optional since they are set by conditions and will
|
17956 + | // all be unset when we start evaluation
|
17957 + | #[derive(Default)]
|
17958 + | #[allow(unused_lifetimes)]
|
17959 + | pub(crate) struct ConditionContext<'a> {
|
17960 + | pub(crate) effective_std_region: Option<::std::string::String>,
|
17961 + | pub(crate) partition_result: Option<crate::endpoint_lib::partition::Partition<'a>>,
|
17962 + | pub(crate) url: Option<crate::endpoint_lib::parse_url::Url<'a>>,
|
17963 + | pub(crate) access_point_suffix: Option<::std::string::String>,
|
17964 + | pub(crate) region_prefix: Option<::std::string::String>,
|
17965 + | pub(crate) hardware_type: Option<::std::string::String>,
|
17966 + | pub(crate) outpost_id_ssa_2: Option<::std::string::String>,
|
17967 + | pub(crate) s3_e_ds: Option<::std::string::String>,
|
17968 + | pub(crate) s3_e_fips: Option<::std::string::String>,
|
17969 + | pub(crate) s3_e_auth: Option<::std::string::String>,
|
17970 + | pub(crate) s3express_availability_zone_id: ::std::option::Option<::std::string::String>,
|
17971 + | pub(crate) bucket_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
|
17972 + | pub(crate) effective_arn_region: Option<::std::string::String>,
|
17973 + | pub(crate) uri_encoded_bucket: Option<::std::string::String>,
|
17974 + | pub(crate) arn_type: ::std::option::Option<::std::string::String>,
|
17975 + | pub(crate) access_point_name_ssa_1: ::std::option::Option<::std::string::String>,
|
17976 + | pub(crate) bucket_partition: Option<crate::endpoint_lib::partition::Partition<'a>>,
|
17977 + | pub(crate) outpost_id_ssa_1: ::std::option::Option<::std::string::String>,
|
17978 + | pub(crate) outpost_type: ::std::option::Option<::std::string::String>,
|
17979 + | pub(crate) access_point_name_ssa_2: ::std::option::Option<::std::string::String>,
|
17980 + | // Sometimes none of the members reference the lifetime, this makes it still valid
|
17981 + | phantom: std::marker::PhantomData<&'a ()>,
|
17982 + | }
|
17983 + |
|
10304 17984 | #[non_exhaustive]
|
10305 17985 | #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
|
10306 17986 | /// Configuration parameters for resolving the correct endpoint
|
10307 17987 | pub struct Params {
|
10308 17988 | /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
|
10309 17989 | pub(crate) bucket: ::std::option::Option<::std::string::String>,
|
10310 17990 | /// The AWS region used to dispatch the request.
|
10311 17991 | pub(crate) region: ::std::option::Option<::std::string::String>,
|
10312 17992 | /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
|
10313 17993 | pub(crate) use_fips: bool,
|