AWS SDK

pub(crate) mod arn;

pub(crate) mod bdd_interpreter;

pub(crate) mod coalesce;

pub(crate) mod diagnostic;

pub(crate) mod ite;

pub(crate) mod partition;

pub(crate) mod split;

#[derive(Debug, Eq, PartialEq, Clone, Default)]

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/*

 *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 *  SPDX-License-Identifier: Apache-2.0

 */

//TODO(bdd): Should this just be an [i32; 3]? Might make it easier to make things const?

/// Binary Decision Diagram node representation

#[derive(Debug, Clone, Copy)]

pub(crate) struct BddNode {

    pub condition_index: i32,

    pub high_ref: i32,

    pub low_ref: i32,

}

/// Evaluates a BDD to resolve an endpoint result

///

/// Arguments

/// * `nodes` - Array of BddNodes

/// * `conditions` - Array of conditions referenced by nodes

/// * `results` - Array of possible results

/// * `root_ref` - Root reference to start evaluation

/// * `params` - Parameters for condition evaluation

/// * `context` - Values that can be set/mutated by the conditions

/// * `diagnostic_collector` - a struct for collecting information about the execution of conditions

/// * `condition_evaluator` - Function to evaluate individual conditions with params and context

///

/// Returns

/// * `Some(R)` - Result if evaluation succeeds

/// * `None` - No match found

#[allow(clippy::too_many_arguments)]

pub(crate) fn evaluate_bdd<'a, Cond, Params, Res: Clone, Context>(

    nodes: &[BddNode],

    conditions: &[Cond],

    results: &[Res],

    root_ref: i32,

    params: &'a Params,

    context: &mut Context,

    diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector,

    mut condition_evaluator: impl FnMut(&Cond, &'a Params, &mut Context, &mut crate::endpoint_lib::diagnostic::DiagnosticCollector) -> bool,

) -> Option<Res> {

    let mut current_ref = root_ref;

    loop {

        match current_ref {

            // Result references (>= 100_000_000)

            ref_val if ref_val >= 100_000_000 => {

                let result_index = (ref_val - 100_000_000) as usize;

                return results.get(result_index).cloned();

            }

            // Terminals (1 = TRUE, -1 = FALSE) NoMatchRule

            1 | -1 => return results.first().cloned(),

            // Node references

            ref_val => {

                let is_complement = ref_val < 0;

                let node_index = (ref_val.abs() - 1) as usize;

                let node = nodes.get(node_index)?;

                let condition_index = node.condition_index as usize;

                let condition = conditions.get(condition_index)?;

                let condition_result = condition_evaluator(condition, params, context, diagnostic_collector);

                // Handle complement edges: complement inverts the branch selection

                current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };

            }

        }

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

//! Coalesce function that returns the first non-None value.

/*

 * Implementation Note: Autoderef Specialization

 *

 * This implementation uses autoderef specialization to dispatch to different

 * coalesce behaviors based on the types of the two arguments at compile time.

 *

 * The technique exploits Rust's method resolution, which automatically dereferences

 * types to find matching method implementations. Method resolution prefers implementations

 * that require fewer dereferences, creating a priority ordering.

 *

 * Three specialization levels (highest to lowest priority):

 *

 * 1. `&&&(&Option<T>, &Option<T>)` - Both args are Option

 *    Returns: Option<T> via a.or(b)

 *

 * 2. `&&(&Option<T>, &T)` - First arg is Option, second is concrete

 *    Returns: T via a.unwrap_or(b)

 *

 * 3. `&(&T, &U)` - Both args are concrete (or any other combination)

 *    Returns: T (always returns first arg)

 *

 * The macro call `(&&&(&a, &b)).coalesce()` starts with three references. Method resolution

 * tries each impl in order by dereferencing:

 * - First tries `&&&(&Option<T>, &Option<T>)` (no deref needed) - matches if both are Option

 * - Then tries `&&(&Option<T>, &T)` (one deref) - matches if first is Option, second isn't

 * - Finally tries `&(&T, &U)` (two derefs) - matches everything else

 *

 * This allows the macro to handle Option/non-Option combinations without runtime checks,

 * selecting the appropriate coalesce logic at compile time based on argument types.

 */

/// Helper trait to implement the coalesce! macro

pub(crate) trait Coalesce {

    /// The first arg

    type Arg1;

    /// The second arg

    type Arg2;

    /// The result of comparing Arg1 and Arg1

    type Result;

    /// Evaluates arguments in order and returns the first non-empty result, otherwise returns the result of the last argument.

    fn coalesce(&self) -> fn(Self::Arg1, Self::Arg2) -> Self::Result;

}

impl<T> Coalesce for &&&(&Option<T>, &Option<T>) {

    type Arg1 = Option<T>;

    type Arg2 = Option<T>;

    type Result = Option<T>;

    fn coalesce(&self) -> fn(Self::Arg1, Self::Arg2) -> Self::Result {

        |a: Option<T>, b: Option<T>| a.or(b)

    }

}

impl<T> Coalesce for &&(&Option<T>, &T) {

    type Arg1 = Option<T>;

    type Arg2 = T;

    type Result = T;

    fn coalesce(&self) -> fn(Self::Arg1, Self::Arg2) -> Self::Result {

        |a: Option<T>, b: T| a.unwrap_or(b)

    }

}

impl<T, U> Coalesce for &(&T, &U) {

    type Arg1 = T;

    type Arg2 = U;

    type Result = T;

    fn coalesce(&self) -> fn(Self::Arg1, Self::Arg2) -> Self::Result {

        |a: T, _b| a

    }

}

/// Evaluates arguments in order and returns the first non-empty result, otherwise returns the result of the last argument.

macro_rules! coalesce {

    ($a:expr) => {$a};

    ($a:expr, $b:expr) => {{

        use crate::endpoint_lib::coalesce::Coalesce;

        let a = $a;

        let b = $b;

        (&&&(&a, &b)).coalesce()(a, b)

    }};

    ($a:expr, $b:expr $(, $c:expr)* $(,)?) => {

        $crate::endpoint_lib::coalesce::coalesce!($crate::endpoint_lib::coalesce::coalesce!($a, $b) $(, $c)*)

    }

}

pub(crate) use coalesce;

#[cfg(test)]

mod test {

    use super::*;

    #[test]

    fn base_cases() {

        // All types optional

        let a = Some("a");

        let b = Some("b");

        assert_eq!(coalesce!(a, b), Some("a"));

        let a = None;

        let b = Some("b");

        assert_eq!(coalesce!(a, b), Some("b"));

        let a = Some("a");

        let b = None;

        assert_eq!(coalesce!(a, b), Some("a"));

        let a: Option<&str> = None;

        let b: Option<&str> = None;

        assert_eq!(coalesce!(a, b), None);

        // Some non-optional types

        let a = "a";

        let b = Some("b");

        assert_eq!(coalesce!(a, b), "a");

        let a = Some("a");

        let b = "b";

        assert_eq!(coalesce!(a, b), "a");

        let a = None;

        let b = "b";

        assert_eq!(coalesce!(a, b), "b");

        let a = "a";

        let b: Option<&str> = None;

        assert_eq!(coalesce!(a, b), "a");

        // All types non-optional

        let a = "a";

        let b = "b";

        assert_eq!(coalesce!(a, b), "a");

        // Works with trailing comma (makes codegen easier)

        let a = "a";

        let b = "b";

        assert_eq!(coalesce!(a, b,), "a");

    }

    #[test]

    fn longer_cases() {

        assert_eq!(coalesce!(None, None, None, None, None, None, None, None, None, None, "a"), "a");

        // In the generated code all of the inputs are typed variables, so the turbofish isn't needed in practice

        assert_eq!(

            coalesce!(

                None,

                None,

                None,

                None,

                "a",

                None::<&str>,

                None::<&str>,

                None::<&str>,

                None::<&str>,

                None::<&str>,

                None::<&str>

            ),

            "a"

        );

        assert_eq!(

            coalesce!(

                None,

                None,

                None,

                None,

                "a",

                None::<&str>,

                Some("b"),

                None::<&str>,

                None::<&str>,

                None::<&str>,

                "c"

            ),

            "a"

        );

        assert_eq!(coalesce!(None, None, None, Some("a"), None, None, None, None, None, None, "b"), "a");

        assert_eq!(

            coalesce!(Some("a"), None, None, Some("b"), None, None, None, None, None, None,),

            Some("a")

        );

        assert_eq!(coalesce!("a", "b", "c", "d", "e", "f", "g",), "a");

        assert_eq!(coalesce!(None, None, None, None, None, None, None, None, None, None::<&str>,), None);

    }

}

    #[allow(dead_code)]

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

//! if-then-else (ite) function that takes in a bool and two (portentially optional)

//! values, choosing which one of those values to return based on the value

//! of the bool.

// Implementation Note: ite uses the same autoderef specialization trick as the coalesce

// macro. You can read more about how it works in the block comment above that macro.

/// Helper trait to implement the ite! macro

pub(crate) trait Ite {

    /// The first arg

    type Arg1;

    /// The second arg

    type Arg2;

    /// The result type

    type Result;

    /// Evaluates arguments, returns Arg1 if the boolean is true, and Arg2 if it is false

    fn ite(&self) -> fn(&bool, Self::Arg1, Self::Arg2) -> Self::Result;

}

impl<T> Ite for &&&&(&Option<T>, &Option<T>) {

    type Arg1 = Option<T>;

    type Arg2 = Option<T>;

    type Result = Option<T>;

    fn ite(&self) -> fn(&bool, Self::Arg1, Self::Arg2) -> Self::Result {

        |b: &bool, true_val: Option<T>, false_val: Option<T>| {

            if *b {

                true_val

            } else {

                false_val

            }

        }

    }

}

impl<T> Ite for &&&(&Option<T>, &T) {

    type Arg1 = Option<T>;

    type Arg2 = T;

    type Result = Option<T>;

    fn ite(&self) -> fn(&bool, Self::Arg1, Self::Arg2) -> Self::Result {

        |b: &bool, true_val: Option<T>, false_val: T| {

            if *b {

                true_val

            } else {

                Some(false_val)

            }

        }

    }

}

impl<T> Ite for &&(&T, &Option<T>) {

    type Arg1 = T;

    type Arg2 = Option<T>;

    type Result = Option<T>;

    fn ite(&self) -> fn(&bool, Self::Arg1, Self::Arg2) -> Self::Result {

        |b: &bool, true_val: T, false_val: Option<T>| {

            if *b {

                Some(true_val)

            } else {

                false_val

            }

        }

    }

}

impl<T> Ite for &(&T, &T) {

    type Arg1 = T;

    type Arg2 = T;

    type Result = T;

    fn ite(&self) -> fn(&bool, Self::Arg1, Self::Arg2) -> Self::Result {

        |b: &bool, true_val: T, false_val: T| {

            if *b {

                true_val

            } else {

                false_val

            }

        }

    }

}

macro_rules! ite {

    ($b:expr, $true_val:expr, $false_val:expr) => {{

        use crate::endpoint_lib::ite::Ite;

        let b = $b;

        let true_val = $true_val;

        let false_val = $false_val;

        (&&&&(&true_val, &false_val)).ite()(&b, true_val, false_val)

    }};

}

pub(crate) use ite;

#[cfg(test)]

mod test {

    use super::*;

    #[test]

    fn base_cases() {

        // All types optional

        let a = "a";

        let some_a = Some("a");

        let b = "b";

        let some_b = Some("b");

        let none: Option<&str> = None;

        // Option, Option

        assert_eq!(ite!(true, some_a, some_b), Some("a"));

        assert_eq!(ite!(false, some_a, some_b), Some("b"));

        assert_eq!(ite!(false, some_a, none), None);

        assert_eq!(ite!(true, some_a, none), Some("a"));

        // Option, Value

        assert_eq!(ite!(true, some_a, b), Some("a"));

        assert_eq!(ite!(false, some_a, b), Some("b"));

        assert_eq!(ite!(true, none, b), None);

        assert_eq!(ite!(false, none, b), Some("b"));

        // Value, Option

        assert_eq!(ite!(true, a, some_b), Some("a"));

        assert_eq!(ite!(false, a, some_b), Some("b"));

        assert_eq!(ite!(false, a, none), None);

        assert_eq!(ite!(true, a, none), Some("a"));

        // Value, Value

        assert_eq!(ite!(true, a, b), "a");

        assert_eq!(ite!(false, a, b), "b");

    }

}

#[derive(PartialEq, Debug, Clone)]

impl Default for Url<'_> {

    fn default() -> Self {

        Self {

            uri: Uri::from_static("https://localhost"),

            url: ParsedUrl::parse("https://localhost").unwrap(),

            raw: "https://localhost",

        }

    }

}

#[derive(Debug, Default, Clone)]

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/*

 *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 *  SPDX-License-Identifier: Apache-2.0

 */

use crate::endpoint_lib::diagnostic::DiagnosticCollector;

/// Splits a string into an array of substrings based on a delimiter.

/// Specification for this function can be found in the [Smithy spec](https://smithy.io/2.0/additional-specs/rules-engine/standard-library.html#split-function).

///

/// ### Arguments

/// * `value` - The input string to split

/// * `delimiter` - The separator (must be non-empty)

/// * `limit` - Controls split behavior:

///   - `0`: Split all occurrences

///   - `1`: No split (returns original string as single element)

///   - `>1`: Split into at most 'limit' parts

///

/// ### Returns

/// `Vec<&str>` containing the split parts

//TODO(BDD): Might be better to return Vec<String>, will play with it when I get some codegen tests that actually use this function

pub(crate) fn split<'a>(value: &'a str, delimiter: &str, limit: usize, _dc: &mut DiagnosticCollector) -> Vec<&'a str> {

    if limit == 0 {

        return value.split(delimiter).collect();

    }

    value.splitn(limit, delimiter).collect()

}

// Test cases sourced from Smithy spec:

// https://smithy.io/2.0/additional-specs/rules-engine/standard-library.html#rules-engine-standard-library-split-examples

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn test_split_unlimited() {

        assert_eq!(split("a--b--c", "--", 0, &mut DiagnosticCollector::new()), vec!["a", "b", "c"]);

        assert_eq!(

            split("--x-s3--azid--suffix", "--", 0, &mut DiagnosticCollector::new()),

            vec!["", "x-s3", "azid", "suffix"]

        );

    }

    #[test]

    fn test_split_with_limit() {

        assert_eq!(split("a--b--c", "--", 2, &mut DiagnosticCollector::new()), vec!["a", "b--c"]);

        assert_eq!(

            split("--x-s3--azid--suffix", "--", 2, &mut DiagnosticCollector::new()),

            vec!["", "x-s3--azid--suffix"]

        );

    }

    #[test]

    fn test_split_no_split() {

        assert_eq!(split("a--b--c", "--", 1, &mut DiagnosticCollector::new()), vec!["a--b--c"]);

        assert_eq!(split("mybucket", "--", 1, &mut DiagnosticCollector::new()), vec!["mybucket"]);

    }

    #[test]

    fn test_split_empty_string() {

        assert_eq!(split("", "--", 0, &mut DiagnosticCollector::new()), vec![""]);

    }

    #[test]

    fn test_split_delimiter_only() {

        assert_eq!(split("--", "--", 0, &mut DiagnosticCollector::new()), vec!["", ""]);

        assert_eq!(split("----", "--", 0, &mut DiagnosticCollector::new()), vec!["", "", ""]);

    }

    #[test]

    fn test_split_with_empty_parts() {

        assert_eq!(split("--b--", "--", 0, &mut DiagnosticCollector::new()), vec!["", "b", ""]);

    }

    #[test]

    fn test_split_no_delimiter_found() {

        assert_eq!(split("abc", "x", 0, &mut DiagnosticCollector::new()), vec!["abc"]);

    }

}

impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_bucket_abac::GetBucketAbacError, R>> for Error

where

    R: Send + Sync + std::fmt::Debug + 'static,

{

    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_bucket_abac::GetBucketAbacError, R>) -> Self {

        match err {

            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),

            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {

                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),

                source: err.into(),

            }),

        }

    }

}

impl From<crate::operation::get_bucket_abac::GetBucketAbacError> for Error {

    fn from(err: crate::operation::get_bucket_abac::GetBucketAbacError) -> Self {

        match err {

            crate::operation::get_bucket_abac::GetBucketAbacError::Unhandled(inner) => Error::Unhandled(inner),

        }

    }

}

impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::put_bucket_abac::PutBucketAbacError, R>> for Error

where

    R: Send + Sync + std::fmt::Debug + 'static,

{

    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::put_bucket_abac::PutBucketAbacError, R>) -> Self {

        match err {

            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),

            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {

                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),

                source: err.into(),

            }),

        }

    }

}

impl From<crate::operation::put_bucket_abac::PutBucketAbacError> for Error {

    fn from(err: crate::operation::put_bucket_abac::PutBucketAbacError) -> Self {

        match err {

            crate::operation::put_bucket_abac::PutBucketAbacError::Unhandled(inner) => Error::Unhandled(inner),

        }

    }

}

/// Types for the `GetBucketAbac` operation.

pub mod get_bucket_abac;

/// Types for the `PutBucketAbac` operation.

pub mod put_bucket_abac;

/// </ul><important>

/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>

/// </important>

    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>

    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>

    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>

    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>

    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>

    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>