Struct ConfigBag

pub struct ConfigBag { /* private fields */ }

Layered configuration structure

See the module docs for more documentation.

Implementations

impl ConfigBag

pub fn base() -> ConfigBag

Create a new config bag “base”.

pub fn of_layers(layers: impl IntoIterator<Item = Layer>) -> ConfigBag

Create a ConfigBag consisting of the given layers.

pub fn push_layer(&mut self, layer: Layer) -> &mut ConfigBag

Add the given layer to the config bag.

pub fn push_shared_layer(&mut self, layer: FrozenLayer) -> &mut ConfigBag

Add a frozen/shared layer to the config bag.

pub fn interceptor_state(&mut self) -> &mut Layer

Return a mutable reference to the interceptor state.

pub fn load<T>(&self) -> <<T as Storable>::Storer as Store>::ReturnedType<'_>

where T: Storable,

Load a value (or values) of type T depending on how T implements Storable

pub fn get_mut_from_interceptor_state<T>(&mut self) -> Option<&mut T>

where T: Storable<Storer = StoreReplace<T>> + Send + Sync + Debug + 'static,

Return a mutable reference to T if found within the interceptor state.

This method does not search the tail of the config bag (i.e., the collection of frozen layers).

If the caller is unsure whether T exists in the interceptor state, consider using Self::get_mut instead, which requires T to implement Clone, however.

pub fn get_mut<T>(&mut self) -> Option<&mut T>

where T: Storable<Storer = StoreReplace<T>> + Send + Sync + Debug + Clone + 'static,

Return a mutable reference to T if found within the config bag

This method requires T to implement Clone because, if the requested item is found in the tail of the config bag, it will be cloned and moved to the head (i.e., the interceptor state).

If the caller is certain that T already exists in the interceptor state, consider using Self::get_mut_from_interceptor_state instead, which does not require T to be Clone.

pub fn get_mut_or_default<T>(&mut self) -> &mut T

where T: Storable<Storer = StoreReplace<T>> + Send + Sync + Debug + Clone + Default + 'static,

Returns a mutable reference to T if it is stored in the top layer of the bag

• If T is in a deeper layer of the bag, that value will be cloned and inserted into the top layer
• If T is not present in the bag, the Default implementation will be used.

pub fn get_mut_or_else<T>(&mut self, default: impl Fn() -> T) -> &mut T

where T: Storable<Storer = StoreReplace<T>> + Send + Sync + Debug + Clone + 'static,

Returns a mutable reference to T if it is stored in the top layer of the bag

• If T is in a deeper layer of the bag, that value will be cloned and inserted into the top layer
• If T is not present in the bag, default will be used to construct a new value

pub fn with_fn( self, name: impl Into<Cow<'static, str>>, next: impl Fn(&mut Layer), ) -> ConfigBag

Add another layer to this configuration bag

Hint: If you want to re-use this layer, call freeze first.

Examples

use aws_smithy_types::config_bag::{ConfigBag, Layer, Storable, StoreReplace};

#[derive(Debug, Eq, PartialEq)]
struct ExampleStr(&'static str);
impl Storable for ExampleStr {
    type Storer = StoreReplace<Self>;
}

#[derive(Debug, Eq, PartialEq)]
struct ExampleInt(i32);
impl Storable for ExampleInt {
    type Storer = StoreReplace<Self>;
}

let mut bag = ConfigBag::base();
bag = bag.with_fn("first", |layer: &mut Layer| { layer.store_put(ExampleStr("a")); });

// We can now load the example string out
assert_eq!(bag.load::<ExampleStr>(), Some(&ExampleStr("a")));

// But there isn't a number stored in the bag yet
assert_eq!(bag.load::<ExampleInt>(), None);

// Add a layer with an example int
bag = bag.with_fn("second", |layer: &mut Layer| { layer.store_put(ExampleInt(1)); });

// Now the example int can be retrieved
assert_eq!(bag.load::<ExampleInt>(), Some(&ExampleInt(1)));

pub fn add_layer(self, name: impl Into<Cow<'static, str>>) -> ConfigBag

Add a new layer with name after freezing the top layer so far

pub fn sourced_get<T>(&self) -> <T as Store>::ReturnedType<'_>

where T: Store,

Return a value (or values) of type T depending on how it has been stored in a ConfigBag

It flexibly chooses to return a single value vs. an iterator of values depending on how T implements a Store trait.

Trait Implementations

impl Debug for ConfigBag

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

Formats the value using the given formatter.