Struct SerializerConfig 

pub struct SerializerConfig { /* private fields */ }

Configures how values are serialized into environment variables.

The value has to serialize to a map (for instance a struct or a map type). The names are the keys with the prefix in front, nested keys are joined with the separator and uppercased (see Case). Keys whose names would not read back as the same keys are an error: keys that contain the separator (or end with a part of it), and different keys with the same name (like a and A). Sequences are written with indexes (APP_HOSTS__0), use the Separated adapter to write them into a single variable. Null values (like None) of map entries are skipped, null values in sequences are written as empty values. Maps and sequences that are empty are not written as variables cannot represent them.

Numbers are written with the shortest text that reads back as the same value, booleans as true and false and bytes as base64 (or the BytesFormat of the context). Keys that are empty or contain the separator are an error as they would not read back.

use deser_env::SerializerConfig;

#[derive(deser::Serialize)]
struct Config {
    name: &'static str,
    server: Server,
    hosts: Vec<&'static str>,
}

#[derive(deser::Serialize)]
struct Server {
    port: u16,
    timeout: Option<u32>,
}

let config = Config {
    name: "shop",
    server: Server { port: 80, timeout: None },
    hosts: vec!["a", "b"],
};
let vars = SerializerConfig::new().to_vars("APP_", &config).unwrap();
let vars: Vec<_> =
    vars.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
assert_eq!(
    vars,
    [
        ("APP_NAME", "shop"),
        ("APP_SERVER__PORT", "80"),
        ("APP_HOSTS__0", "a"),
        ("APP_HOSTS__1", "b"),
    ]
);

Implementations

impl SerializerConfig

pub const fn new() -> SerializerConfig

Creates the default configuration.

pub const fn builder() -> SerializerConfigBuilder

Returns a builder for the configuration (see SerializerConfigBuilder).

pub const fn into_builder(self) -> SerializerConfigBuilder

Returns a builder that starts with this configuration.

pub fn set_context(&mut self, context: Context)

Sets the context the values are serialized in.

The values of the context are the defaults of the extension values of the state (see Context), for instance the BytesFormat. A context set on the driver (for instance in the setup callback of to_vars_with) takes precedence.

pub fn context(&self) -> &Context

Returns the context the values are serialized in.

pub const fn set_separator(&mut self, separator: &'static str)

Sets the separator of nested keys.

The default is __, see DeserializerConfig::set_separator. With the empty string nested maps and sequences are an error.

pub const fn set_case(&mut self, case: Case)

Sets how keys map onto names.

The default is Case::Upper which uppercases keys.

pub fn to_vars<T: Serialize + ?Sized>( &self, prefix: &str, value: &T, ) -> Result<Vec<(String, String)>, Error>

Serializes a value into variables with a prefix.

See to_vars.

pub fn to_vars_with<F, T: Serialize + ?Sized>( &self, prefix: &str, value: &T, setup: F, ) -> Result<Vec<(String, String)>, Error>

where F: FnOnce(&mut SerializeDriver<'_>),

Serializes a value into variables with a prefix and a configured driver.

The callback is invoked with the driver before the serialization starts, for instance to add Layers.

Trait Implementations

impl Clone for SerializerConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SerializerConfig

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

Formats the value using the given formatter.

impl Default for SerializerConfig

fn default() -> SerializerConfig

Returns the “default value” for a type.

impl Eq for SerializerConfig

impl PartialEq for SerializerConfig

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SerializerConfig