Enum KeyedContainerBuilder 

pub enum KeyedContainerBuilder<Container, Target> {
    Unspecified,
    Some(Container),
    _PhantomData(PhantomData<fn() -> Target>),
}

Builder type for keyed containers, such as HashMap (as opposed to unkeyed containers like Vec). This is not required to be used, but is a convient shortcut for map types’ implementations.

Types using this as their builder must implement KeyedContainer.

For unkeyed containers, see UnkeyedContainerBuilder.

Example usage:

use std::fmt::Display;

use confik::{
    helpers::{BuilderOf, KeyedContainer, KeyedContainerBuilder},
    Configuration,
};
use serde::Deserialize;

struct MyMap<K, V> {
    // ...
}

impl<'de, K, V> Deserialize<'de> for MyMap<K, V> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // ...
    }
}

impl<K, V> Default for MyMap<K, V> {
    fn default() -> Self {
        // ...
    }
}

impl<K, V> IntoIterator for MyMap<K, V> {
    type Item = (K, V);

    type IntoIter = // ...

    fn into_iter(self) -> Self::IntoIter {
        // ...
    }
}

impl<'a, K, V> IntoIterator for &'a MyMap<K, V> {
    type Item = (&'a K, &'a V);

    type IntoIter = // ...

    fn into_iter(self) -> Self::IntoIter {
        // ...
    }
}

impl<K, V> FromIterator<(K, V)> for MyMap<K, V> {
    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
        // ...
    }
}

impl<K, V> KeyedContainer for MyMap<K, V> {
    type Key = K;

    type Value = V;

    fn insert(&mut self, k: Self::Key, v: Self::Value) {
        // ...
    }

    fn remove(&mut self, k: &Self::Key) -> Option<Self::Value> {
        // ...
    }
}

impl<K, V> Configuration for MyMap<K, V>
where
    K: Display + 'static,
    V: Configuration,
    BuilderOf<V>: 'static,
{
    type Builder = KeyedContainerBuilder<MyMap<K, BuilderOf<V>>, Self>;
}

Variants

Unspecified

No data has been provided yet.

Default to None but allow overwriting by later merges.

Some(Container)

Data has been provided.

Will not be overwritten by later merges.

_PhantomData(PhantomData<fn() -> Target>)

Never instantiated, used to hold the Target type.

Trait Implementations

impl<Container, Target> ConfigurationBuilder for KeyedContainerBuilder<Container, Target>

where Self: DeserializeOwned, Container: KeyedContainer + IntoIterator<Item = (KeyOf<Container>, ValueOf<Container>)> + 'static, KeyOf<Container>: Display, ValueOf<Container>: ConfigurationBuilder + 'static, Target: Default + FromIterator<(KeyOf<Container>, TargetOf<ValueOf<Container>>)>, for<'a> &'a Container: IntoIterator<Item = (&'a KeyOf<Container>, &'a ValueOf<Container>)>,

type Target = Target

The target that will be converted into. See Configuration.

fn merge(self, other: Self) -> Self

Combines two builders recursively, preferring self’s data, if present.

fn try_build(self) -> Result<Self::Target, Error>

This will probably delegate to TryInto but allows it to be implemented for types foreign to the library.

fn contains_non_secret_data(&self) -> Result<bool, UnexpectedSecret>

Called recursively on each field, aiming to hit all SecretBuilders. This is only called when Source::allows_secrets is false.

impl<Container: Debug, Target: Debug> Debug for KeyedContainerBuilder<Container, Target>

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

Formats the value using the given formatter.

impl<Container, Target> Default for KeyedContainerBuilder<Container, Target>

fn default() -> KeyedContainerBuilder<Container, Target>

Returns the “default value” for a type.

impl<'de, Container, Target> Deserialize<'de> for KeyedContainerBuilder<Container, Target>

where Container: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Container, Target> From<Container> for KeyedContainerBuilder<Container, Target>

fn from(value: Container) -> Self

Converts to this type from the input type.

impl<Container: Hash, Target: Hash> Hash for KeyedContainerBuilder<Container, Target>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Container: Ord, Target: Ord> Ord for KeyedContainerBuilder<Container, Target>

fn cmp(&self, other: &KeyedContainerBuilder<Container, Target>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Container: PartialEq, Target: PartialEq> PartialEq for KeyedContainerBuilder<Container, Target>

fn eq(&self, other: &KeyedContainerBuilder<Container, Target>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Container: PartialOrd, Target: PartialOrd> PartialOrd for KeyedContainerBuilder<Container, Target>

fn partial_cmp( &self, other: &KeyedContainerBuilder<Container, Target>, ) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<Container: Eq, Target: Eq> Eq for KeyedContainerBuilder<Container, Target>

impl<Container, Target> StructuralPartialEq for KeyedContainerBuilder<Container, Target>