Struct Delimited

pub struct Delimited<De = (), S = &'static str>(pub De, pub S);

Deserializer that supports either an array of values, or a string in which values are delimited by the specified separator.

Examples

use std::{collections::HashSet, path::PathBuf};
use smart_config::{de, pat::lazy_regex, testing, DescribeConfig, DeserializeConfig};

#[derive(DescribeConfig, DeserializeConfig)]
struct TestConfig {
    #[config(default, with = de::Delimited::new(","))]
    strings: Vec<String>,
    // More complex types are supported as well (along with custom base deserializers).
    // Importantly, the base deserializer still refers to the entire collection, not its items,
    // so you should use something like `Repeated`, or use the `repeat()` constructor.
    #[config(with = de::Delimited::repeat(de::Serde![str], ":"))]
    paths: Vec<PathBuf>,
    // ...and more complex collections (here together with string -> number coercion
    // and a regex-based splitter)
    #[config(with = de::Delimited::new(lazy_regex!(ref r"\s*;\s*")))]
    ints: HashSet<u64>,
}

let sample = smart_config::config!(
    "strings": ["test", "string"], // standard array value is still supported
    "paths": "/usr/bin:/usr/local/bin",
    "ints": "12; 34 ; 12",
);
let config: TestConfig = testing::test(sample)?;
assert_eq!(config.strings.len(), 2);
assert_eq!(config.strings[0], "test");
assert_eq!(config.paths.len(), 2);
assert_eq!(config.paths[1].as_os_str(), "/usr/local/bin");
assert_eq!(config.ints, HashSet::from([12, 34]));

The wrapping logic is smart enough to catch in compile time an attempt to apply Delimited to a type that cannot be deserialized from an array:

use smart_config::{de, DescribeConfig, DeserializeConfig};

#[derive(DescribeConfig, DeserializeConfig)]
struct Fail {
    // will fail with "evaluation of `<Delimited as DeserializeParam<u64>>::EXPECTING` failed"
    #[config(default, with = de::Delimited::new(","))]
    test: u64,
}

Tuple Fields

0: De

1: S

Implementations

impl<S: Split> Delimited<(), S>

pub const fn new(sep: S) -> Self

Creates a new deserializer that can be used for WellKnown collections.

impl<De, S: Split> Delimited<Repeated<De>, S>

pub const fn repeat(item_de: De, sep: S) -> Self

Shortcut to wrap a Repeated deserializer.

Trait Implementations

impl<De: Debug, S: Split> Debug for Delimited<De, S>

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

Formats the value using the given formatter.

impl<T, De, S> DeserializeParam<T> for Delimited<De, S>

where De: DeserializeParam<T>, S: Split,

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.