[][src]Constant oration::config::_IMPL_DESERIALIZE_FOR_Config

const _IMPL_DESERIALIZE_FOR_Config: () = {
    #[allow(unknown_lints)]
    #[allow(rust_2018_idioms)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl <'de> _serde::Deserialize<'de> for Config {
        fn deserialize<__D>(__deserializer: __D)
         -> _serde::export::Result<Self, <__D>::Error> where
         __D: _serde::Deserializer<'de> {
                                            #[allow(non_camel_case_types)]
                                            enum __Field {
                                                __field0,
                                                __field1,
                                                __field2,
                                                __field3,
                                                __field4,
                                                __field5,
                                                __field6,
                                                __field7,
                                                __ignore,
                                            }
                                            struct __FieldVisitor;
                                            impl <'de>
                                             _serde::de::Visitor<'de> for
                                             __FieldVisitor {
                                                type
                                                Value
                                                =
                                                __Field;
                                                fn expecting(self: &Self,
                                                             __formatter:
                                                                 &mut _serde::export::Formatter)
                                                 ->
                                                     _serde::export::fmt::Result {
                                                                                     loop 
                                                                                          {
                                                                                     }
                                                                                 }
                                                fn visit_u64<__E>(self: Self,
                                                                  __value:
                                                                      u64)
                                                 ->
                                                     _serde::export::Result<<Self>::Value,
                                                                            __E>
                                                 where
                                                 __E: _serde::de::Error {
                                                                            loop 
                                                                                 {
                                                                            }
                                                                        }
                                                fn visit_str<__E>(self: Self,
                                                                  __value:
                                                                      &str)
                                                 ->
                                                     _serde::export::Result<<Self>::Value,
                                                                            __E>
                                                 where
                                                 __E: _serde::de::Error {
                                                                            loop 
                                                                                 {
                                                                            }
                                                                        }
                                                fn visit_bytes<__E>(self:
                                                                        Self,
                                                                    __value:
                                                                        &[u8])
                                                 ->
                                                     _serde::export::Result<<Self>::Value,
                                                                            __E>
                                                 where
                                                 __E: _serde::de::Error {
                                                                            loop 
                                                                                 {
                                                                            }
                                                                        }
                                            }
                                            impl <'de>
                                             _serde::Deserialize<'de> for
                                             __Field {
                                                #[inline]
                                                fn deserialize<__D>(__deserializer:
                                                                        __D)
                                                 ->
                                                     _serde::export::Result<Self,
                                                                            <__D>::Error>
                                                 where
                                                 __D: _serde::Deserializer<'de> {
                                                                                    loop 
                                                                                         {
                                                                                    }
                                                                                }
                                            }
                                            struct __Visitor<'de> {
                                                marker: _serde::export::PhantomData<Config>,
                                                lifetime: _serde::export::PhantomData<&'de ()>,
                                            }
                                            impl <'de>
                                             _serde::de::Visitor<'de> for
                                             __Visitor<'de> {
                                                type
                                                Value
                                                =
                                                Config;
                                                fn expecting(self: &Self,
                                                             __formatter:
                                                                 &mut _serde::export::Formatter)
                                                 ->
                                                     _serde::export::fmt::Result {
                                                                                     loop 
                                                                                          {
                                                                                     }
                                                                                 }
                                                #[inline]
                                                fn visit_seq<__A>(self: Self,
                                                                  mut __seq:
                                                                      __A)
                                                 ->
                                                     _serde::export::Result<<Self>::Value,
                                                                            <__A>::Error>
                                                 where
                                                 __A: _serde::de::SeqAccess<'de> {
                                                                                     loop 
                                                                                          {
                                                                                     }
                                                                                 }
                                                #[inline]
                                                fn visit_map<__A>(self: Self,
                                                                  mut __map:
                                                                      __A)
                                                 ->
                                                     _serde::export::Result<<Self>::Value,
                                                                            <__A>::Error>
                                                 where
                                                 __A: _serde::de::MapAccess<'de> {
                                                                                     loop 
                                                                                          {
                                                                                     }
                                                                                 }
                                            }
                                            const FIELDS:
                                                  &'static [&'static str] =
                                                &["host", "blog_name", "salt",
                                                  "author", "nesting_limit",
                                                  "edit_timeout",
                                                  "notifications",
                                                  "telegram"];
                                            loop  { }
                                        }
    }
}