Struct smart_config::de::OrString

pub struct OrString<De>(pub De);

Deserializer that supports parsing either from a default format (usually an object or array) via Deserialize, or from string via FromStr.

Examples

use anyhow::Context as _;
use smart_config::{de, testing, DescribeConfig, DeserializeConfig};

#[derive(Debug, Serialize, Deserialize)]
#[serde(transparent)]
struct MySet(HashSet<u64>);

impl FromStr for MySet {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.split(',')
            .map(|part| part.trim().parse().context("invalid value"))
            .collect::<anyhow::Result<_>>()
            .map(Self)
    }
}

#[derive(DescribeConfig, DeserializeConfig)]
struct TestConfig {
    #[config(with = de::OrString(de::Serde![array]))]
    value: MySet,
}

let sample = smart_config::config!("value": "2, 3, 2");
let config: TestConfig = testing::test(sample)?;
assert_eq!(config.value.0, HashSet::from([2, 3]));

// Parsing from array works, too
let sample = smart_config::config!("value": [2, 3, 2]);
let config: TestConfig = testing::test(sample)?;
assert_eq!(config.value.0, HashSet::from([2, 3]));

Tuple Fields

0: De

Trait Implementations

impl<De: Debug> Debug for OrString<De>

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

Formats the value using the given formatter.

impl<T, De> DeserializeParam<T> for OrString<De>

where T: FromStr, T::Err: Display, De: DeserializeParam<T>,

const EXPECTING: BasicTypes = _

Describes which parameter this deserializer is expecting.

fn describe(&self, description: &mut TypeDescription)

Additional info about the deserialized type, e.g., extended description.

fn deserialize_param( &self, ctx: DeserializeContext<'_>, param: &'static ParamMetadata, ) -> Result<T, ErrorWithOrigin>

Performs deserialization given the context and param metadata.

fn serialize_param(&self, param: &T) -> Value

Serializes the provided parameter to the JSON model.