Enum MultilineListBuilder 

#[non_exhaustive]
pub enum MultilineListBuilder<EB> {
    Unspecified,
    String(String),
    List(Vec<EB>),
}

Configuration item specifiable as a list, or a single multi-line string

If a list is supplied, they are deserialized as builders. If a single string is supplied, it is split into lines, and #-comments and blank lines and whitespace are stripped, and then each line is parsed as a builder. (Eventually, the builders will be built.)

For use with sub_builder and define_list_builder_helper, with #[serde(try_from)] and #[serde(into)].

Example

use derive_builder::Builder;
use serde::{Deserialize, Serialize};
use tor_config::{ConfigBuildError, MultilineListBuilder};
use tor_config::convert_helper_via_multi_line_list_builder;
use tor_config::{define_list_builder_accessors, define_list_builder_helper};
use tor_config::impl_standard_builder;


#[derive(Debug, Clone, Builder, Eq, PartialEq)]
#[builder(build_fn(error = "ConfigBuildError"))]
#[builder(derive(Debug, Serialize, Deserialize))]
#[non_exhaustive]
pub struct LotteryConfig {
    /// What numbers should win the lottery?  Setting this is lottery fraud.
    #[builder(sub_builder, setter(custom))]
    #[builder_field_attr(serde(default))]
    winners: LotteryNumberList,
}
impl_standard_builder! { LotteryConfig }

/// List of lottery winners
//
// This type alias arranges that we can put `LotteryNumberList` in `LotteryConfig`
// and have derive_builder put a `LotteryNumberListBuilder` in `LotteryConfigBuilder`.
pub type LotteryNumberList = Vec<u16>;

define_list_builder_helper! {
    struct LotteryNumberListBuilder {
        numbers: [u16],
    }
    built: LotteryNumberList = numbers;
    default = generate_random();
    item_build: |number| Ok(*number);
    #[serde(try_from="MultilineListBuilder<u16>")]
    #[serde(into="MultilineListBuilder<u16>")]
}

convert_helper_via_multi_line_list_builder! {
    struct LotteryNumberListBuilder {
        numbers: [u16],
    }
}

define_list_builder_accessors! {
    struct LotteryConfigBuilder {
        pub winners: [u16],
    }
}

let lc: LotteryConfigBuilder = toml::from_str(r#"winners = [1,2,3]"#).unwrap();
let lc = lc.build().unwrap();
assert_eq!{ lc.winners, [1,2,3] }

let lc = r#"
winners = '''
  # Enny tells us this is the ticket they bought:

  4
  5
  6
'''
"#;
let lc: LotteryConfigBuilder = toml::from_str(lc).unwrap();
let lc = lc.build().unwrap();
assert_eq!{ lc.winners, [4,5,6] }

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unspecified

Config key not present

String(String)

Config key was a string which is to be parsed line-by-line

List(Vec<EB>)

Config key was a list of the individual entry builders

Trait Implementations

impl<EB> Clone for MultilineListBuilder<EB>

where EB: Clone,

fn clone(&self) -> MultilineListBuilder<EB>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<EB> Debug for MultilineListBuilder<EB>

where EB: Debug,

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

Formats the value using the given formatter.

impl<EB> Default for MultilineListBuilder<EB>

fn default() -> MultilineListBuilder<EB>

Returns the “default value” for a type.

impl<'de, EB> Deserialize<'de> for MultilineListBuilder<EB>

where EB: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<MultilineListBuilder<EB>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<EB> From<Option<Vec<EB>>> for MultilineListBuilder<EB>

fn from(list: Option<Vec<EB>>) -> MultilineListBuilder<EB>

Converts to this type from the input type.

impl<EB> Serialize for MultilineListBuilder<EB>

where EB: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<EB> TryInto<Option<Vec<EB>>> for MultilineListBuilder<EB>

where EB: FromStr, <EB as FromStr>::Err: Error + Clone + Send + Sync,

type Error = MultilineListBuilderError<<EB as FromStr>::Err>

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<Option<Vec<EB>>, <MultilineListBuilder<EB> as TryInto<Option<Vec<EB>>>>::Error>

Performs the conversion.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes

Size for each variant:

• Unspecified: 0 bytes
• String: 24 bytes
• List: 24 bytes