Constant librsnek::system::primitives::_IMPL_SERIALIZE_FOR_Frame [] [src]

const _IMPL_SERIALIZE_FOR_Frame: () = {
    extern crate serde as _serde;
    #[automatically_derived]
    impl _serde::Serialize for Frame {
        fn serialize<__S>(self: &Self, __serializer: __S)
         -> _serde::export::Result<<__S>::Ok, <__S>::Error> where
         __S: _serde::Serializer {
                                     let mut __serde_state =
                                         match _serde::Serializer::serialize_struct(__serializer,
                                                                                    "Frame",
                                                                                    0
                                                                                        +
                                                                                        1
                                                                                        +
                                                                                        1
                                                                                        +
                                                                                        1
                                                                                        +
                                                                                        1
                                                                                        +
                                                                                        1)
                                             {
                                             ::result::Result::Ok(val) => val,
                                             ::result::Result::Err(err) => {
                                                 return ::result::Result::Err(::convert::From::from(err))
                                             }
                                         };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "f_back",
                                                                                         &self.f_back)
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "f_code",
                                                                                         &self.f_code)
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "f_builtins",
                                                                                         &self.f_builtins)
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "f_lasti",
                                                                                         {
                                                                                             struct __SerializeWith<'__a> {
                                                                                                 value: &'__a Integer,
                                                                                                 phantom: _serde::export::PhantomData<Frame>,
                                                                                             }
                                                                                             impl <'__a>
                                                                                              _serde::Serialize
                                                                                              for
                                                                                              __SerializeWith<'__a>
                                                                                              {
                                                                                                 fn serialize<__S>(self:
                                                                                                                       &Self,
                                                                                                                   __s:
                                                                                                                       __S)
                                                                                                  ->
                                                                                                      _serde::export::Result<<__S>::Ok,
                                                                                                                             <__S>::Error>
                                                                                                  where
                                                                                                  __S: _serde::Serializer {
                                                                                                                              serialize::integer(self.value,
                                                                                                                                                 __s)
                                                                                                                          }
                                                                                             }
                                                                                             &__SerializeWith{value:
                                                                                                                  &self.f_lasti,
                                                                                                              phantom:
                                                                                                                  _serde::export::PhantomData::<Frame>,}
                                                                                         })
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
                                                                                         "blocks",
                                                                                         &self.blocks)
                                         {
                                         ::result::Result::Ok(val) => val,
                                         ::result::Result::Err(err) => {
                                             return ::result::Result::Err(::convert::From::from(err))
                                         }
                                     };
                                     _serde::ser::SerializeStruct::end(__serde_state)
                                 }
    }
}