serde_macros 0.6.14

Macros to auto-generate implementations for the serde framework
#![feature(prelude_import)]
#![no_std]
#![feature(test, custom_attribute, custom_derive, plugin)]
#![plugin(serde_macros)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;

extern crate num;
extern crate serde;
extern crate test;


use std::str::FromStr;
use serde::{Serialize, Serializer, Deserialize, Deserializer};
trait Trait: Sized {
    fn my_default()
    -> Self;
    fn should_skip(&self)
    -> bool;
    fn serialize_with<S>(&self, ser: &mut S)
    -> Result<(), S::Error>
    where
    S: Serializer;
    fn deserialize_with<D>(de: &mut D)
    -> Result<Self, D::Error>
    where
    D: Deserializer;
}
impl Trait for i32 {
    fn my_default() -> Self { 123 }
    fn should_skip(&self) -> bool { *self == 123 }
    fn serialize_with<S>(&self, ser: &mut S) -> Result<(), S::Error> where
     S: Serializer {
        if *self == 123 { true.serialize(ser) } else { false.serialize(ser) }
    }
    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error> where
     D: Deserializer {
        let s: String =
            match Deserialize::deserialize(de) {
                ::std::result::Result::Ok(val) => val,
                ::std::result::Result::Err(err) => {
                    return ::std::result::Result::Err(::std::convert::From::from(err))
                }
            };
        Ok(i32::from_str(&s).unwrap())
    }
}
struct DeserializeWithStruct {
    a: i8,
    #[serde(deserialize_with = "i32::deserialize_with(deserializer)")]
    b: i32,
}
impl ::serde::de::Deserialize for DeserializeWithStruct {
    fn deserialize<__D>(deserializer: &mut __D)
     -> ::std::result::Result<DeserializeWithStruct, __D::Error> where
     __D: ::serde::de::Deserializer {
        {
            #[allow(non_camel_case_types)]
            enum __Field { __field0, __field1, __ignore, }
            impl ::serde::de::Deserialize for __Field {
                #[inline]
                fn deserialize<D>(deserializer: &mut D)
                 -> ::std::result::Result<__Field, D::Error> where
                 D: ::serde::de::Deserializer {
                    use std::marker::PhantomData;
                    struct __FieldVisitor<D> {
                        phantom: PhantomData<D>,
                    }
                    impl <__D> ::serde::de::Visitor for __FieldVisitor<__D>
                     where __D: ::serde::de::Deserializer {
                        type
                        Value
                        =
                        __Field;
                        fn visit_usize<E>(&mut self, value: usize)
                         -> ::std::result::Result<__Field, E> where
                         E: ::serde::de::Error {
                            match value {
                                0usize => { Ok(__Field::__field0) }
                                1usize => { Ok(__Field::__field1) }
                                _ => {
                                    Err(::serde::de::Error::syntax("expected a field"))
                                }
                            }
                        }
                        fn visit_str<E>(&mut self, value: &str)
                         -> ::std::result::Result<__Field, E> where
                         E: ::serde::de::Error {
                            match value {
                                "a" => { Ok(__Field::__field0) }
                                "b" => { Ok(__Field::__field1) }
                                _ => Ok(__Field::__ignore),
                            }
                        }
                        fn visit_bytes<E>(&mut self, value: &[u8])
                         -> ::std::result::Result<__Field, E> where
                         E: ::serde::de::Error {
                            match ::std::str::from_utf8(value) {
                                Ok(s) => self.visit_str(s),
                                _ => {
                                    Err(::serde::de::Error::syntax("could not convert a byte string to a String"))
                                }
                            }
                        }
                    }
                    deserializer.deserialize_struct_field(__FieldVisitor::<D>{phantom:
                                                                                  PhantomData,})
                }
            }
            struct __Visitor<__D: ::serde::de::Deserializer>(::std::marker::PhantomData<__D>);
            impl <__D: ::serde::de::Deserializer> ::serde::de::Visitor for
             __Visitor<__D> {
                type
                Value
                =
                DeserializeWithStruct;
                #[inline]
                fn visit_seq<__V>(&mut self, mut visitor: __V)
                 -> ::std::result::Result<DeserializeWithStruct, __V::Error>
                 where __V: ::serde::de::SeqVisitor {
                    {
                        let __field0 =
                            match match visitor.visit() {
                                      ::std::result::Result::Ok(val) => val,
                                      ::std::result::Result::Err(err) => {
                                          return ::std::result::Result::Err(::std::convert::From::from(err))
                                      }
                                  } {
                                Some(value) => { value }
                                None => {
                                    return Err(::serde::de::Error::end_of_stream());
                                }
                            };
                        let __field1 =
                            match match visitor.visit() {
                                      ::std::result::Result::Ok(val) => val,
                                      ::std::result::Result::Err(err) => {
                                          return ::std::result::Result::Err(::std::convert::From::from(err))
                                      }
                                  } {
                                Some(value) => { value }
                                None => {
                                    return Err(::serde::de::Error::end_of_stream());
                                }
                            };
                        match visitor.end() {
                            ::std::result::Result::Ok(val) => val,
                            ::std::result::Result::Err(err) => {
                                return ::std::result::Result::Err(::std::convert::From::from(err))
                            }
                        };
                        Ok(DeserializeWithStruct{a: __field0, b: __field1,})
                    }
                }
                #[inline]
                fn visit_map<__V>(&mut self, mut visitor: __V)
                 -> ::std::result::Result<DeserializeWithStruct, __V::Error>
                 where __V: ::serde::de::MapVisitor {
                    {
                        let mut __field0 = None;
                        let mut __field1 = None;
                        while let Some(key) =
                                  match visitor.visit_key() {
                                      ::std::result::Result::Ok(val) => val,
                                      ::std::result::Result::Err(err) => {
                                          return ::std::result::Result::Err(::std::convert::From::from(err))
                                      }
                                  } {
                            match key {
                                __Field::__field0 => {
                                    __field0 =
                                        Some(match visitor.visit_value() {
                                                 ::std::result::Result::Ok(val)
                                                 => val,
                                                 ::std::result::Result::Err(err)
                                                 => {
                                                     return ::std::result::Result::Err(::std::convert::From::from(err))
                                                 }
                                             });
                                }
                                __Field::__field1 => {
                                    __field1 =
                                        Some(match {
                                                       fn __serde_deserialize_with<__D: ::serde::de::Deserialize>(deserializer:
                                                                                                                      &mut __D)
                                                        -> i32 {
                                                           i32::deserialize_with(deserializer)
                                                       }
                                                       struct __SerdeDeserializeWithStruct {
                                                           value: i32,
                                                       }
                                                       impl ::serde::de::Deserialize
                                                        for
                                                        __SerdeDeserializeWithStruct
                                                        {
                                                           fn deserialize<D>(deserializer:
                                                                                 &mut D)
                                                            ->
                                                                Result<Self,
                                                                       D::Error>
                                                            where
                                                            D: ::serde::de::Deserializer {
                                                               let value =
                                                                   match __serde_deserialize_with(deserializer)
                                                                       {
                                                                       ::std::result::Result::Ok(val)
                                                                       => val,
                                                                       ::std::result::Result::Err(err)
                                                                       => {
                                                                           return ::std::result::Result::Err(::std::convert::From::from(err))
                                                                       }
                                                                   };
                                                               Ok(__SerdeDeserializeWithStruct{value:
                                                                                                   value,})
                                                           }
                                                       }
                                                       let value:
                                                               __SerdeDeserializeWithStruct =
                                                           match visitor.visit_value()
                                                               {
                                                               ::std::result::Result::Ok(val)
                                                               => val,
                                                               ::std::result::Result::Err(err)
                                                               => {
                                                                   return ::std::result::Result::Err(::std::convert::From::from(err))
                                                               }
                                                           };
                                                       value.value
                                                   } {
                                                 ::std::result::Result::Ok(val)
                                                 => val,
                                                 ::std::result::Result::Err(err)
                                                 => {
                                                     return ::std::result::Result::Err(::std::convert::From::from(err))
                                                 }
                                             });
                                }
                                _ => {
                                    match visitor.visit_value::<::serde::de::impls::IgnoredAny>()
                                        {
                                        ::std::result::Result::Ok(val) => val,
                                        ::std::result::Result::Err(err) => {
                                            return ::std::result::Result::Err(::std::convert::From::from(err))
                                        }
                                    };
                                }
                            }
                        }
                        let __field0 =
                            match __field0 {
                                Some(__field0) => __field0,
                                None =>
                                match visitor.missing_field("a") {
                                    ::std::result::Result::Ok(value) => value,
                                    ::std::result::Result::Err(value) =>
                                    return ::std::result::Result::Err(value),
                                },
                            };
                        let __field1 =
                            match __field1 {
                                Some(__field1) => __field1,
                                None =>
                                match visitor.missing_field("b") {
                                    ::std::result::Result::Ok(value) => value,
                                    ::std::result::Result::Err(value) =>
                                    return ::std::result::Result::Err(value),
                                },
                            };
                        match visitor.end() {
                            ::std::result::Result::Ok(val) => val,
                            ::std::result::Result::Err(err) => {
                                return ::std::result::Result::Err(::std::convert::From::from(err))
                            }
                        };
                        Ok(DeserializeWithStruct{a: __field0, b: __field1,})
                    }
                }
            }
            const FIELDS: &'static [&'static str] = &["a", "b"];
            deserializer.deserialize_struct("DeserializeWithStruct", FIELDS,
                                            __Visitor::<__D>(::std::marker::PhantomData))
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::cmp::PartialEq for DeserializeWithStruct {
    #[inline]
    fn eq(&self, __arg_0: &DeserializeWithStruct) -> bool {
        match *__arg_0 {
            DeserializeWithStruct { a: ref __self_1_0, b: ref __self_1_1 } =>
            match *self {
                DeserializeWithStruct { a: ref __self_0_0, b: ref __self_0_1 }
                =>
                true && (*__self_0_0) == (*__self_1_0) &&
                    (*__self_0_1) == (*__self_1_1),
            },
        }
    }
    #[inline]
    fn ne(&self, __arg_0: &DeserializeWithStruct) -> bool {
        match *__arg_0 {
            DeserializeWithStruct { a: ref __self_1_0, b: ref __self_1_1 } =>
            match *self {
                DeserializeWithStruct { a: ref __self_0_0, b: ref __self_0_1 }
                =>
                false || (*__self_0_0) != (*__self_1_0) ||
                    (*__self_0_1) != (*__self_1_1),
            },
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::fmt::Debug for DeserializeWithStruct {
    fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        match *self {
            DeserializeWithStruct { a: ref __self_0_0, b: ref __self_0_1 } =>
            {
                let mut builder =
                    __arg_0.debug_struct("DeserializeWithStruct");
                let _ = builder.field("a", &&(*__self_0_0));
                let _ = builder.field("b", &&(*__self_0_1));
                builder.finish()
            }
        }
    }
}
mod compile_tests {
    #[prelude_import]
    use std::prelude::v1::*;
    extern crate compiletest_rs as compiletest;
    use std::path::PathBuf;
    use std::env::var;
    fn run_mode(mode: &'static str) {
        let mut config = compiletest::default_config();
        let cfg_mode = mode.parse().ok().expect("Invalid mode");
        config.target_rustcflags =
            Some("-L target/debug/ -L target/debug/deps/".to_owned());
        if let Ok(name) = var::<&str>("TESTNAME") {
            let s: String = name.to_owned();
            config.filter = Some(s)
        }
        config.mode = cfg_mode;
        config.src_base =
            PathBuf::from(::std::fmt::format(::std::fmt::Arguments::new_v1({
                                                                               static __STATIC_FMTSTR:
                                                                                      &'static [&'static str]
                                                                                      =
                                                                                   &["tests/"];
                                                                               __STATIC_FMTSTR
                                                                           },
                                                                           &match (&mode,)
                                                                                {
                                                                                (__arg0,)
                                                                                =>
                                                                                [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                             ::std::fmt::Display::fmt)],
                                                                            })));
        compiletest::run_tests(&config);
    }
    #[test]
    pub fn compile_test() { run_mode("compile-fail"); }
    pub mod __test_reexports {
        #[prelude_import]
        use std::prelude::v1::*;
        pub use super::compile_test;
    }
}
pub mod __test_reexports {
    #[prelude_import]
    use std::prelude::v1::*;
    pub use super::compile_tests::__test_reexports as compile_tests;
}
pub mod __test {
    #[prelude_import]
    use std::prelude::v1::*;
    extern crate test;
    #[main]
    pub fn main() -> () { test::test_main_static(TESTS); }
    const TESTS: &'static [self::test::TestDescAndFn] =
        &[self::test::TestDescAndFn{desc:
                                        self::test::TestDesc{name:
                                                                 self::test::StaticTestName("compile_tests::compile_test"),
                                                             ignore: false,
                                                             should_panic:
                                                                 self::test::ShouldPanic::No,},
                                    testfn:
                                        self::test::StaticTestFn(::__test_reexports::compile_tests::compile_test),}];
}