#![feature(prelude_import)] #![allow(dead_code)] #[prelude_import] use std::prelude::rust_2021::*; #[macro_use] extern crate std; use clap_rs as clap; use clap::{Parser, Subcommand, CommandFactory}; use twelf::{config, Layer}; #[serde(crate = "::twelf::reexports::serde")] # [clap (author , version , about , long_about = None)] struct Config { #[clap(long, help = "Documentation inside clap, to specifiy db_host")] db_host: String, #[clap(long, short, help = "The number of threads")] #[clap(required = false)] threads: usize, #[clap(long, short, help = "Put in verbose mode")] verbose: bool, } impl clap::Parser for Config {} #[allow(dead_code, unreachable_code, unused_variables, unused_braces)] #[allow( clippy::style, clippy::complexity, clippy::pedantic, clippy::restriction, clippy::perf, clippy::deprecated, clippy::nursery, clippy::cargo, clippy::suspicious_else_formatting )] #[deny(clippy::correctness)] #[allow(deprecated)] impl clap::CommandFactory for Config { fn into_app<'b>() -> clap::Command<'b> { let __clap_app = clap::Command::new("twelf"); ::augment_args(__clap_app) } fn into_app_for_update<'b>() -> clap::Command<'b> { let __clap_app = clap::Command::new("twelf"); ::augment_args_for_update(__clap_app) } } #[allow(dead_code, unreachable_code, unused_variables, unused_braces)] #[allow( clippy::style, clippy::complexity, clippy::pedantic, clippy::restriction, clippy::perf, clippy::deprecated, clippy::nursery, clippy::cargo, clippy::suspicious_else_formatting )] #[deny(clippy::correctness)] impl clap::FromArgMatches for Config { fn from_arg_matches( __clap_arg_matches: &clap::ArgMatches, ) -> ::std::result::Result { let v = Config { db_host: __clap_arg_matches .value_of("db-host") .ok_or_else(|| { clap::Error::raw(clap::ErrorKind::MissingRequiredArgument, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["The following required argument was not provided: "], &[::core::fmt::ArgumentV1::new_display(&"db-host")], )); res }) }) .and_then(|s| { ::std::str::FromStr::from_str(s).map_err(|err| { clap::Error::raw(clap::ErrorKind::ValueValidation, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["Invalid value for ", ": "], &[ ::core::fmt::ArgumentV1::new_display(&"db-host"), ::core::fmt::ArgumentV1::new_display(&err), ], )); res }) }) })?, threads: __clap_arg_matches .value_of("threads") .ok_or_else(|| { clap::Error::raw(clap::ErrorKind::MissingRequiredArgument, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["The following required argument was not provided: "], &[::core::fmt::ArgumentV1::new_display(&"threads")], )); res }) }) .and_then(|s| { ::std::str::FromStr::from_str(s).map_err(|err| { clap::Error::raw(clap::ErrorKind::ValueValidation, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["Invalid value for ", ": "], &[ ::core::fmt::ArgumentV1::new_display(&"threads"), ::core::fmt::ArgumentV1::new_display(&err), ], )); res }) }) })?, verbose: __clap_arg_matches.is_present("verbose"), }; ::std::result::Result::Ok(v) } fn update_from_arg_matches( &mut self, __clap_arg_matches: &clap::ArgMatches, ) -> ::std::result::Result<(), clap::Error> { if __clap_arg_matches.is_present("db-host") { #[allow(non_snake_case)] let db_host = &mut self.db_host; *db_host = __clap_arg_matches .value_of("db-host") .ok_or_else(|| { clap::Error::raw(clap::ErrorKind::MissingRequiredArgument, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["The following required argument was not provided: "], &[::core::fmt::ArgumentV1::new_display(&"db-host")], )); res }) }) .and_then(|s| { ::std::str::FromStr::from_str(s).map_err(|err| { clap::Error::raw(clap::ErrorKind::ValueValidation, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["Invalid value for ", ": "], &[ ::core::fmt::ArgumentV1::new_display(&"db-host"), ::core::fmt::ArgumentV1::new_display(&err), ], )); res }) }) })? } if __clap_arg_matches.is_present("threads") { #[allow(non_snake_case)] let threads = &mut self.threads; *threads = __clap_arg_matches .value_of("threads") .ok_or_else(|| { clap::Error::raw(clap::ErrorKind::MissingRequiredArgument, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["The following required argument was not provided: "], &[::core::fmt::ArgumentV1::new_display(&"threads")], )); res }) }) .and_then(|s| { ::std::str::FromStr::from_str(s).map_err(|err| { clap::Error::raw(clap::ErrorKind::ValueValidation, { let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["Invalid value for ", ": "], &[ ::core::fmt::ArgumentV1::new_display(&"threads"), ::core::fmt::ArgumentV1::new_display(&err), ], )); res }) }) })? } if __clap_arg_matches.is_present("verbose") { #[allow(non_snake_case)] let verbose = &mut self.verbose; *verbose = *verbose || __clap_arg_matches.is_present("verbose") } ::std::result::Result::Ok(()) } } #[allow(dead_code, unreachable_code, unused_variables, unused_braces)] #[allow( clippy::style, clippy::complexity, clippy::pedantic, clippy::restriction, clippy::perf, clippy::deprecated, clippy::nursery, clippy::cargo, clippy::suspicious_else_formatting )] #[deny(clippy::correctness)] impl clap::Args for Config { fn augment_args<'b>(__clap_app: clap::Command<'b>) -> clap::Command<'b> { { let __clap_app = __clap_app; let __clap_app = __clap_app.arg( clap::Arg::new("db-host") .takes_value(true) .value_name("DB_HOST") .required(true) .validator(|s| ::std::str::FromStr::from_str(s).map(|_: String| ())) .long("db-host") .help("Documentation inside clap, to specifiy db_host"), ); let __clap_app = __clap_app.arg( clap::Arg::new("threads") .takes_value(true) .value_name("THREADS") .required(true) .validator(|s| ::std::str::FromStr::from_str(s).map(|_: usize| ())) .long("threads") .short('\u{74}') .help("The number of threads") .required(false), ); let __clap_app = __clap_app.arg( clap::Arg::new("verbose") .long("verbose") .short('\u{76}') .help("Put in verbose mode"), ); __clap_app . author ("Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>") . version ("0.4.0") . about ("Twelf is a configuration solution for Rust including 12-Factor support. It is designed with layers in order to configure different sources and formats to build your configuration. The main goal is to be very simple using a proc macro.") . long_about (None) } } fn augment_args_for_update<'b>(__clap_app: clap::Command<'b>) -> clap::Command<'b> { { let __clap_app = __clap_app; let __clap_app = __clap_app.arg( clap::Arg::new("db-host") .takes_value(true) .value_name("DB_HOST") .required(false) .validator(|s| ::std::str::FromStr::from_str(s).map(|_: String| ())) .long("db-host") .help("Documentation inside clap, to specifiy db_host"), ); let __clap_app = __clap_app.arg( clap::Arg::new("threads") .takes_value(true) .value_name("THREADS") .required(false) .validator(|s| ::std::str::FromStr::from_str(s).map(|_: usize| ())) .long("threads") .short('\u{74}') .help("The number of threads") .required(false), ); let __clap_app = __clap_app.arg( clap::Arg::new("verbose") .long("verbose") .short('\u{76}') .help("Put in verbose mode"), ); __clap_app . author ("Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>") . version ("0.4.0") . about ("Twelf is a configuration solution for Rust including 12-Factor support. It is designed with layers in order to configure different sources and formats to build your configuration. The main goal is to be very simple using a proc macro.") . long_about (None) } } } #[automatically_derived] #[allow(unused_qualifications)] impl ::core::fmt::Debug for Config { fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { match *self { Config { db_host: ref __self_0_0, threads: ref __self_0_1, verbose: ref __self_0_2, } => { let debug_trait_builder = &mut ::core::fmt::Formatter::debug_struct(f, "Config"); let _ = ::core::fmt::DebugStruct::field( debug_trait_builder, "db_host", &&(*__self_0_0), ); let _ = ::core::fmt::DebugStruct::field( debug_trait_builder, "threads", &&(*__self_0_1), ); let _ = ::core::fmt::DebugStruct::field( debug_trait_builder, "verbose", &&(*__self_0_2), ); ::core::fmt::DebugStruct::finish(debug_trait_builder) } } } } #[doc(hidden)] #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] const _: () = { use ::twelf::reexports::serde as _serde; #[automatically_derived] impl<'de> ::twelf::reexports::serde::Deserialize<'de> for Config { fn deserialize<__D>( __deserializer: __D, ) -> ::twelf::reexports::serde::__private::Result where __D: ::twelf::reexports::serde::Deserializer<'de>, { #[allow(non_camel_case_types)] enum __Field { __field0, __field1, __field2, __ignore, } struct __FieldVisitor; impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { type Value = __Field; fn expecting( &self, __formatter: &mut _serde::__private::Formatter, ) -> _serde::__private::fmt::Result { _serde::__private::Formatter::write_str(__formatter, "field identifier") } fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result where __E: _serde::de::Error, { match __value { 0u64 => _serde::__private::Ok(__Field::__field0), 1u64 => _serde::__private::Ok(__Field::__field1), 2u64 => _serde::__private::Ok(__Field::__field2), _ => _serde::__private::Ok(__Field::__ignore), } } fn visit_str<__E>( self, __value: &str, ) -> _serde::__private::Result where __E: _serde::de::Error, { match __value { "db_host" => _serde::__private::Ok(__Field::__field0), "threads" => _serde::__private::Ok(__Field::__field1), "verbose" => _serde::__private::Ok(__Field::__field2), _ => _serde::__private::Ok(__Field::__ignore), } } fn visit_bytes<__E>( self, __value: &[u8], ) -> _serde::__private::Result where __E: _serde::de::Error, { match __value { b"db_host" => _serde::__private::Ok(__Field::__field0), b"threads" => _serde::__private::Ok(__Field::__field1), b"verbose" => _serde::__private::Ok(__Field::__field2), _ => _serde::__private::Ok(__Field::__ignore), } } } impl<'de> _serde::Deserialize<'de> for __Field { #[inline] fn deserialize<__D>( __deserializer: __D, ) -> _serde::__private::Result where __D: _serde::Deserializer<'de>, { _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) } } struct __Visitor<'de> { marker: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData<&'de ()>, } impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { type Value = Config; fn expecting( &self, __formatter: &mut _serde::__private::Formatter, ) -> _serde::__private::fmt::Result { _serde::__private::Formatter::write_str(__formatter, "struct Config") } #[inline] fn visit_seq<__A>( self, mut __seq: __A, ) -> _serde::__private::Result where __A: _serde::de::SeqAccess<'de>, { let __field0 = match match _serde::de::SeqAccess::next_element::(&mut __seq) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { _serde::__private::Some(__value) => __value, _serde::__private::None => { return _serde::__private::Err(_serde::de::Error::invalid_length( 0usize, &"struct Config with 3 elements", )); } }; let __field1 = match match _serde::de::SeqAccess::next_element::(&mut __seq) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { _serde::__private::Some(__value) => __value, _serde::__private::None => { return _serde::__private::Err(_serde::de::Error::invalid_length( 1usize, &"struct Config with 3 elements", )); } }; let __field2 = match match _serde::de::SeqAccess::next_element::(&mut __seq) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { _serde::__private::Some(__value) => __value, _serde::__private::None => { return _serde::__private::Err(_serde::de::Error::invalid_length( 2usize, &"struct Config with 3 elements", )); } }; _serde::__private::Ok(Config { db_host: __field0, threads: __field1, verbose: __field2, }) } #[inline] fn visit_map<__A>( self, mut __map: __A, ) -> _serde::__private::Result where __A: _serde::de::MapAccess<'de>, { let mut __field0: _serde::__private::Option = _serde::__private::None; let mut __field1: _serde::__private::Option = _serde::__private::None; let mut __field2: _serde::__private::Option = _serde::__private::None; while let _serde::__private::Some(__key) = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { match __key { __Field::__field0 => { if _serde::__private::Option::is_some(&__field0) { return _serde::__private::Err( <__A::Error as _serde::de::Error>::duplicate_field( "db_host", ), ); } __field0 = _serde::__private::Some( match _serde::de::MapAccess::next_value::(&mut __map) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }, ); } __Field::__field1 => { if _serde::__private::Option::is_some(&__field1) { return _serde::__private::Err( <__A::Error as _serde::de::Error>::duplicate_field( "threads", ), ); } __field1 = _serde::__private::Some( match _serde::de::MapAccess::next_value::(&mut __map) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }, ); } __Field::__field2 => { if _serde::__private::Option::is_some(&__field2) { return _serde::__private::Err( <__A::Error as _serde::de::Error>::duplicate_field( "verbose", ), ); } __field2 = _serde::__private::Some( match _serde::de::MapAccess::next_value::(&mut __map) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }, ); } _ => { let _ = match _serde::de::MapAccess::next_value::< _serde::de::IgnoredAny, >(&mut __map) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }; } } } let __field0 = match __field0 { _serde::__private::Some(__field0) => __field0, _serde::__private::None => { match _serde::__private::de::missing_field("db_host") { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } } }; let __field1 = match __field1 { _serde::__private::Some(__field1) => __field1, _serde::__private::None => { match _serde::__private::de::missing_field("threads") { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } } }; let __field2 = match __field2 { _serde::__private::Some(__field2) => __field2, _serde::__private::None => { match _serde::__private::de::missing_field("verbose") { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } } }; _serde::__private::Ok(Config { db_host: __field0, threads: __field1, verbose: __field2, }) } } const FIELDS: &'static [&'static str] = &["db_host", "threads", "verbose"]; _serde::Deserializer::deserialize_struct( __deserializer, "Config", FIELDS, __Visitor { marker: _serde::__private::PhantomData::, lifetime: _serde::__private::PhantomData, }, ) } } }; impl Config { pub fn with_layers(layers: &[::twelf::Layer]) -> Result { use std::iter::FromIterator; let mut res: std::collections::HashMap = std::collections::HashMap::new(); for layer in layers { let extension = Self::parse_twelf(layer)?; res.extend( extension .as_object() .ok_or_else(|| ::twelf::Error::InvalidFormat)? .to_owned() .into_iter() .filter(|(_k, v)| !v.is_null()), ); } { let lvl = ::log::Level::Debug; if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { ::log::__private_api_log( ::core::fmt::Arguments::new_v1(&["configuration:"], &[]), lvl, &( "twelf", "clap_derive", "twelf/examples/clap_derive.rs", 7u32, ), ::log::__private_api::Option::None, ); } }; for (key, val) in &res { { let lvl = ::log::Level::Debug; if lvl <= ::log::STATIC_MAX_LEVEL && lvl <= ::log::max_level() { ::log::__private_api_log( ::core::fmt::Arguments::new_v1( &["", "="], &[ ::core::fmt::ArgumentV1::new_display(&key), ::core::fmt::ArgumentV1::new_display(&val), ], ), lvl, &( "twelf", "clap_derive", "twelf/examples/clap_derive.rs", 7u32, ), ::log::__private_api::Option::None, ); } }; } ::twelf::reexports::serde_json::from_value(::twelf::reexports::serde_json::Value::Object( ::twelf::reexports::serde_json::Map::from_iter(res.into_iter()), )) .map_err(|e| { ::twelf::Error::Deserialize({ let res = ::alloc::fmt::format(::core::fmt::Arguments::new_v1( &["config error: "], &[::core::fmt::ArgumentV1::new_display(&e.to_string())], )); res }) }) } pub fn clap_args() -> Vec<::twelf::reexports::clap::Arg<'static>> { <[_]>::into_vec(box [ ::twelf::reexports::clap::Arg::new("db-host") .long("db-host") .help("") .takes_value(!false) .global(true), ::twelf::reexports::clap::Arg::new("threads") .long("threads") .help("") .takes_value(!false) .global(true), ::twelf::reexports::clap::Arg::new("verbose") .long("verbose") .help("") .takes_value(!true) .global(true), ]) } fn parse_twelf( priority: &::twelf::Layer, ) -> Result<::twelf::reexports::serde_json::Value, ::twelf::Error> { #[serde(crate = "::twelf::reexports::serde")] struct OptConfig { db_host: Option, threads: Option, verbose: Option, } #[doc(hidden)] #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] const _: () = { use ::twelf::reexports::serde as _serde; #[automatically_derived] impl<'de> ::twelf::reexports::serde::Deserialize<'de> for OptConfig { fn deserialize<__D>( __deserializer: __D, ) -> ::twelf::reexports::serde::__private::Result where __D: ::twelf::reexports::serde::Deserializer<'de>, { #[allow(non_camel_case_types)] enum __Field { __field0, __field1, __field2, __ignore, } struct __FieldVisitor; impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { type Value = __Field; fn expecting( &self, __formatter: &mut _serde::__private::Formatter, ) -> _serde::__private::fmt::Result { _serde::__private::Formatter::write_str(__formatter, "field identifier") } fn visit_u64<__E>( self, __value: u64, ) -> _serde::__private::Result where __E: _serde::de::Error, { match __value { 0u64 => _serde::__private::Ok(__Field::__field0), 1u64 => _serde::__private::Ok(__Field::__field1), 2u64 => _serde::__private::Ok(__Field::__field2), _ => _serde::__private::Ok(__Field::__ignore), } } fn visit_str<__E>( self, __value: &str, ) -> _serde::__private::Result where __E: _serde::de::Error, { match __value { "db_host" => _serde::__private::Ok(__Field::__field0), "threads" => _serde::__private::Ok(__Field::__field1), "verbose" => _serde::__private::Ok(__Field::__field2), _ => _serde::__private::Ok(__Field::__ignore), } } fn visit_bytes<__E>( self, __value: &[u8], ) -> _serde::__private::Result where __E: _serde::de::Error, { match __value { b"db_host" => _serde::__private::Ok(__Field::__field0), b"threads" => _serde::__private::Ok(__Field::__field1), b"verbose" => _serde::__private::Ok(__Field::__field2), _ => _serde::__private::Ok(__Field::__ignore), } } } impl<'de> _serde::Deserialize<'de> for __Field { #[inline] fn deserialize<__D>( __deserializer: __D, ) -> _serde::__private::Result where __D: _serde::Deserializer<'de>, { _serde::Deserializer::deserialize_identifier( __deserializer, __FieldVisitor, ) } } struct __Visitor<'de> { marker: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData<&'de ()>, } impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { type Value = OptConfig; fn expecting( &self, __formatter: &mut _serde::__private::Formatter, ) -> _serde::__private::fmt::Result { _serde::__private::Formatter::write_str(__formatter, "struct OptConfig") } #[inline] fn visit_seq<__A>( self, mut __seq: __A, ) -> _serde::__private::Result where __A: _serde::de::SeqAccess<'de>, { let __field0 = match match _serde::de::SeqAccess::next_element::< Option, >(&mut __seq) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { _serde::__private::Some(__value) => __value, _serde::__private::None => { return _serde::__private::Err( _serde::de::Error::invalid_length( 0usize, &"struct OptConfig with 3 elements", ), ); } }; let __field1 = match match _serde::de::SeqAccess::next_element::< Option, >(&mut __seq) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { _serde::__private::Some(__value) => __value, _serde::__private::None => { return _serde::__private::Err( _serde::de::Error::invalid_length( 1usize, &"struct OptConfig with 3 elements", ), ); } }; let __field2 = match match _serde::de::SeqAccess::next_element::< Option, >(&mut __seq) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { _serde::__private::Some(__value) => __value, _serde::__private::None => { return _serde::__private::Err( _serde::de::Error::invalid_length( 2usize, &"struct OptConfig with 3 elements", ), ); } }; _serde::__private::Ok(OptConfig { db_host: __field0, threads: __field1, verbose: __field2, }) } #[inline] fn visit_map<__A>( self, mut __map: __A, ) -> _serde::__private::Result where __A: _serde::de::MapAccess<'de>, { let mut __field0: _serde::__private::Option> = _serde::__private::None; let mut __field1: _serde::__private::Option> = _serde::__private::None; let mut __field2: _serde::__private::Option> = _serde::__private::None; while let _serde::__private::Some(__key) = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } { match __key { __Field::__field0 => { if _serde::__private::Option::is_some(&__field0) { return _serde::__private::Err( <__A::Error as _serde::de::Error>::duplicate_field( "db_host", ), ); } __field0 = _serde::__private::Some( match _serde::de::MapAccess::next_value::>( &mut __map, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }, ); } __Field::__field1 => { if _serde::__private::Option::is_some(&__field1) { return _serde::__private::Err( <__A::Error as _serde::de::Error>::duplicate_field( "threads", ), ); } __field1 = _serde::__private::Some( match _serde::de::MapAccess::next_value::>( &mut __map, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }, ); } __Field::__field2 => { if _serde::__private::Option::is_some(&__field2) { return _serde::__private::Err( <__A::Error as _serde::de::Error>::duplicate_field( "verbose", ), ); } __field2 = _serde::__private::Some( match _serde::de::MapAccess::next_value::>( &mut __map, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }, ); } _ => { let _ = match _serde::de::MapAccess::next_value::< _serde::de::IgnoredAny, >( &mut __map ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }; } } } let __field0 = match __field0 { _serde::__private::Some(__field0) => __field0, _serde::__private::None => { match _serde::__private::de::missing_field("db_host") { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } } }; let __field1 = match __field1 { _serde::__private::Some(__field1) => __field1, _serde::__private::None => { match _serde::__private::de::missing_field("threads") { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } } }; let __field2 = match __field2 { _serde::__private::Some(__field2) => __field2, _serde::__private::None => { match _serde::__private::de::missing_field("verbose") { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } } } }; _serde::__private::Ok(OptConfig { db_host: __field0, threads: __field1, verbose: __field2, }) } } const FIELDS: &'static [&'static str] = &["db_host", "threads", "verbose"]; _serde::Deserializer::deserialize_struct( __deserializer, "OptConfig", FIELDS, __Visitor { marker: _serde::__private::PhantomData::, lifetime: _serde::__private::PhantomData, }, ) } } }; #[doc(hidden)] #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] const _: () = { use ::twelf::reexports::serde as _serde; #[automatically_derived] impl ::twelf::reexports::serde::Serialize for OptConfig { fn serialize<__S>( &self, __serializer: __S, ) -> ::twelf::reexports::serde::__private::Result<__S::Ok, __S::Error> where __S: ::twelf::reexports::serde::Serializer, { let mut __serde_state = match _serde::Serializer::serialize_struct( __serializer, "OptConfig", false as usize + 1 + 1 + 1, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }; match _serde::ser::SerializeStruct::serialize_field( &mut __serde_state, "db_host", &self.db_host, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }; match _serde::ser::SerializeStruct::serialize_field( &mut __serde_state, "threads", &self.threads, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }; match _serde::ser::SerializeStruct::serialize_field( &mut __serde_state, "verbose", &self.verbose, ) { _serde::__private::Ok(__val) => __val, _serde::__private::Err(__err) => { return _serde::__private::Err(__err); } }; _serde::ser::SerializeStruct::end(__serde_state) } } }; let res = match priority { ::twelf::Layer::Env(prefix) => match prefix { Some(prefix) => { let tmp_cfg: OptConfig = ::twelf::reexports::envy::prefixed(prefix).from_env()?; ::twelf::reexports::serde_json::to_value(tmp_cfg) } None => { let tmp_cfg: OptConfig = ::twelf::reexports::envy::from_env()?; ::twelf::reexports::serde_json::to_value(tmp_cfg) } }?, ::twelf::Layer::Json(filepath) => { ::twelf::reexports::serde_json::from_reader(std::fs::File::open(filepath)?)? } ::twelf::Layer::Toml(filepath) => { ::twelf::reexports::toml::from_str(&std::fs::read_to_string(filepath)?)? } ::twelf::Layer::Yaml(filepath) => { ::twelf::reexports::serde_yaml::from_str(&std::fs::read_to_string(filepath)?)? } ::twelf::Layer::Dhall(filepath) => { ::twelf::reexports::serde_dhall::from_str(&std::fs::read_to_string(filepath)?) .parse()? } ::twelf::Layer::Ini(filepath) => { let tmp_cfg: OptConfig = ::twelf::reexports::serde_ini::from_str(&std::fs::read_to_string(filepath)?)?; ::twelf::reexports::serde_json::to_value(tmp_cfg)? } ::twelf::Layer::Clap(matches) => { let mut map: std::collections::HashMap = std::collections::HashMap::new(); if let Some(vmatch) = matches.value_of("db-host") { map.insert(String::from("db_host"), vmatch.to_string()); } else if false { if matches.is_present("db-host") { map.insert(String::from("db_host"), String::from("true")); } } if let Some(vmatch) = matches.value_of("threads") { map.insert(String::from("threads"), vmatch.to_string()); } else if false { if matches.is_present("threads") { map.insert(String::from("threads"), String::from("true")); } } if let Some(vmatch) = matches.value_of("verbose") { map.insert(String::from("verbose"), vmatch.to_string()); } else if true { if matches.is_present("verbose") { map.insert(String::from("verbose"), String::from("true")); } } let tmp_cfg: OptConfig = ::twelf::reexports::envy::from_iter(map.into_iter())?; ::twelf::reexports::serde_json::to_value(tmp_cfg)? } other => ::core::panicking::panic_fmt(::core::fmt::Arguments::new_v1( &["not implemented: "], &[::core::fmt::ArgumentV1::new_display( &::core::fmt::Arguments::new_v1( &[""], &[::core::fmt::ArgumentV1::new_debug(&other)], ), )], )), }; Ok(res) } } fn main() { let matches = Config::command().ignore_errors(true).get_matches(); let config = Config::with_layers(&[Layer::Env(Some(String::from("APP_"))), Layer::Clap(matches)]) .unwrap(); { ::std::io::_print(::core::fmt::Arguments::new_v1( &["config - ", "\n"], &[::core::fmt::ArgumentV1::new_debug(&config)], )); }; }