serde_macros 0.6.14

#![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;


/// An uploaded file that was received as part of `multipart/form-data` parsing.
///
/// Files are streamed to disk because they may not fit in memory.
pub struct UploadedFile {
    /// The temporary file where the data was saved.
    pub path: PathBuf,
    /// The filename that was specified in the data, unfiltered. It may or may not be legal on the
    /// local filesystem.
    pub filename: Option<String>,
    /// The unvalidated content-type that was specified in the data.
    pub content_type: Mime,
    /// The size of the file.
    pub size: usize,
    tempdir: PathBuf,
}
impl ::serde::de::Deserialize for UploadedFile {
    fn deserialize<__D>(deserializer: &mut __D)
     -> ::std::result::Result<UploadedFile, __D::Error> where
     __D: ::serde::de::Deserializer {
        {
            #[allow(non_camel_case_types)]
            enum __Field { __field0, __field1, __field2, __field3, __field4, }
            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) }
                                2usize => { Ok(__Field::__field2) }
                                3usize => { Ok(__Field::__field3) }
                                4usize => { Ok(__Field::__field4) }
                                _ => {
                                    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 {
                                "path" => { Ok(__Field::__field0) }
                                "filename" => { Ok(__Field::__field1) }
                                "content_type" => { Ok(__Field::__field2) }
                                "size" => { Ok(__Field::__field3) }
                                "tempdir" => { Ok(__Field::__field4) }
                                _ => {
                                    Err(::serde::de::Error::unknown_field(value))
                                }
                            }
                        }
                        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.visit_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
                =
                UploadedFile;
                #[inline]
                fn visit_seq<__V>(&mut self, mut visitor: __V)
                 -> ::std::result::Result<UploadedFile, __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());
                                }
                            };
                        let __field2 =
                            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 __field3 =
                            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 __field4 =
                            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(UploadedFile{path: __field0,
                                        filename: __field1,
                                        content_type: __field2,
                                        size: __field3,
                                        tempdir: __field4,})
                    }
                }
                #[inline]
                fn visit_map<__V>(&mut self, mut visitor: __V)
                 -> ::std::result::Result<UploadedFile, __V::Error> where
                 __V: ::serde::de::MapVisitor {
                    {
                        let mut __field0 = None;
                        let mut __field1 = None;
                        let mut __field2 = None;
                        let mut __field3 = None;
                        let mut __field4 = 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 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::__field2 => {
                                    __field2 =
                                        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::__field3 => {
                                    __field3 =
                                        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::__field4 => {
                                    __field4 =
                                        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))
                                                 }
                                             });
                                }
                            }
                        }
                        let __field0 =
                            match __field0 {
                                Some(__field0) => __field0,
                                None =>
                                match visitor.missing_field("path") {
                                    ::std::result::Result::Ok(val) => val,
                                    ::std::result::Result::Err(err) => {
                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                    }
                                },
                            };
                        let __field1 =
                            match __field1 {
                                Some(__field1) => __field1,
                                None =>
                                match visitor.missing_field("filename") {
                                    ::std::result::Result::Ok(val) => val,
                                    ::std::result::Result::Err(err) => {
                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                    }
                                },
                            };
                        let __field2 =
                            match __field2 {
                                Some(__field2) => __field2,
                                None =>
                                match visitor.missing_field("content_type") {
                                    ::std::result::Result::Ok(val) => val,
                                    ::std::result::Result::Err(err) => {
                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                    }
                                },
                            };
                        let __field3 =
                            match __field3 {
                                Some(__field3) => __field3,
                                None =>
                                match visitor.missing_field("size") {
                                    ::std::result::Result::Ok(val) => val,
                                    ::std::result::Result::Err(err) => {
                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                    }
                                },
                            };
                        let __field4 =
                            match __field4 {
                                Some(__field4) => __field4,
                                None =>
                                match visitor.missing_field("tempdir") {
                                    ::std::result::Result::Ok(val) => val,
                                    ::std::result::Result::Err(err) => {
                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                    }
                                },
                            };
                        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(UploadedFile{path: __field0,
                                        filename: __field1,
                                        content_type: __field2,
                                        size: __field3,
                                        tempdir: __field4,})
                    }
                }
            }
            const FIELDS: &'static [&'static str] =
                &["path", "filename", "content_type", "size", "tempdir"];
            deserializer.visit_struct("UploadedFile", FIELDS,
                                      __Visitor::<__D>(::std::marker::PhantomData))
        }
    }
}
impl ::serde::ser::Serialize for UploadedFile {
    fn serialize<__S>(&self, serializer: &mut __S)
     -> ::std::result::Result<(), __S::Error> where
     __S: ::serde::ser::Serializer {
        {
            struct Visitor<'__a> {
                state: usize,
                value: &'__a UploadedFile,
                _structure_ty: ::std::marker::PhantomData<&'__a UploadedFile>,
            }
            impl <'__a> ::serde::ser::MapVisitor for Visitor<'__a> {
                #[inline]
                fn visit<S>(&mut self, serializer: &mut S)
                 -> ::std::result::Result<Option<()>, S::Error> where
                 S: ::serde::ser::Serializer {
                    loop  {
                        match self.state {
                            0usize => {
                                self.state += 1;
                                { }
                                return Ok(Some(match serializer.visit_struct_elt("path",
                                                                                 &self.value.path)
                                                   {
                                                   ::std::result::Result::Ok(val)
                                                   => val,
                                                   ::std::result::Result::Err(err)
                                                   => {
                                                       return ::std::result::Result::Err(::std::convert::From::from(err))
                                                   }
                                               }));
                            }
                            1usize => {
                                self.state += 1;
                                { }
                                return Ok(Some(match serializer.visit_struct_elt("filename",
                                                                                 &self.value.filename)
                                                   {
                                                   ::std::result::Result::Ok(val)
                                                   => val,
                                                   ::std::result::Result::Err(err)
                                                   => {
                                                       return ::std::result::Result::Err(::std::convert::From::from(err))
                                                   }
                                               }));
                            }
                            2usize => {
                                self.state += 1;
                                { }
                                return Ok(Some(match serializer.visit_struct_elt("content_type",
                                                                                 &self.value.content_type)
                                                   {
                                                   ::std::result::Result::Ok(val)
                                                   => val,
                                                   ::std::result::Result::Err(err)
                                                   => {
                                                       return ::std::result::Result::Err(::std::convert::From::from(err))
                                                   }
                                               }));
                            }
                            3usize => {
                                self.state += 1;
                                { }
                                return Ok(Some(match serializer.visit_struct_elt("size",
                                                                                 &self.value.size)
                                                   {
                                                   ::std::result::Result::Ok(val)
                                                   => val,
                                                   ::std::result::Result::Err(err)
                                                   => {
                                                       return ::std::result::Result::Err(::std::convert::From::from(err))
                                                   }
                                               }));
                            }
                            4usize => {
                                self.state += 1;
                                { }
                                return Ok(Some(match serializer.visit_struct_elt("tempdir",
                                                                                 &self.value.tempdir)
                                                   {
                                                   ::std::result::Result::Ok(val)
                                                   => val,
                                                   ::std::result::Result::Err(err)
                                                   => {
                                                       return ::std::result::Result::Err(::std::convert::From::from(err))
                                                   }
                                               }));
                            }
                            _ => { return Ok(None); }
                        }
                    }
                }
                #[inline]
                fn len(&self) -> Option<usize> { Some(0 + 1 + 1 + 1 + 1 + 1) }
            }
            serializer.visit_struct("UploadedFile",
                                    Visitor{value: self,
                                            state: 0,
                                            _structure_ty:
                                                ::std::marker::PhantomData::<&UploadedFile>,})
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::cmp::PartialEq for UploadedFile {
    #[inline]
    fn eq(&self, __arg_0: &UploadedFile) -> bool {
        match *__arg_0 {
            UploadedFile {
            path: ref __self_1_0,
            filename: ref __self_1_1,
            content_type: ref __self_1_2,
            size: ref __self_1_3,
            tempdir: ref __self_1_4 } =>
            match *self {
                UploadedFile {
                path: ref __self_0_0,
                filename: ref __self_0_1,
                content_type: ref __self_0_2,
                size: ref __self_0_3,
                tempdir: ref __self_0_4 } =>
                true && (*__self_0_0) == (*__self_1_0) &&
                    (*__self_0_1) == (*__self_1_1) &&
                    (*__self_0_2) == (*__self_1_2) &&
                    (*__self_0_3) == (*__self_1_3) &&
                    (*__self_0_4) == (*__self_1_4),
            },
        }
    }
    #[inline]
    fn ne(&self, __arg_0: &UploadedFile) -> bool {
        match *__arg_0 {
            UploadedFile {
            path: ref __self_1_0,
            filename: ref __self_1_1,
            content_type: ref __self_1_2,
            size: ref __self_1_3,
            tempdir: ref __self_1_4 } =>
            match *self {
                UploadedFile {
                path: ref __self_0_0,
                filename: ref __self_0_1,
                content_type: ref __self_0_2,
                size: ref __self_0_3,
                tempdir: ref __self_0_4 } =>
                false || (*__self_0_0) != (*__self_1_0) ||
                    (*__self_0_1) != (*__self_1_1) ||
                    (*__self_0_2) != (*__self_1_2) ||
                    (*__self_0_3) != (*__self_1_3) ||
                    (*__self_0_4) != (*__self_1_4),
            },
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::fmt::Debug for UploadedFile {
    fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        match *self {
            UploadedFile {
            path: ref __self_0_0,
            filename: ref __self_0_1,
            content_type: ref __self_0_2,
            size: ref __self_0_3,
            tempdir: ref __self_0_4 } => {
                let mut builder = __arg_0.debug_struct("UploadedFile");
                let _ = builder.field("path", &&(*__self_0_0));
                let _ = builder.field("filename", &&(*__self_0_1));
                let _ = builder.field("content_type", &&(*__self_0_2));
                let _ = builder.field("size", &&(*__self_0_3));
                let _ = builder.field("tempdir", &&(*__self_0_4));
                builder.finish()
            }
        }
    }
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::clone::Clone for UploadedFile {
    #[inline]
    fn clone(&self) -> UploadedFile {
        match *self {
            UploadedFile {
            path: ref __self_0_0,
            filename: ref __self_0_1,
            content_type: ref __self_0_2,
            size: ref __self_0_3,
            tempdir: ref __self_0_4 } =>
            UploadedFile{path: ::std::clone::Clone::clone(&(*__self_0_0)),
                         filename: ::std::clone::Clone::clone(&(*__self_0_1)),
                         content_type:
                             ::std::clone::Clone::clone(&(*__self_0_2)),
                         size: ::std::clone::Clone::clone(&(*__self_0_3)),
                         tempdir:
                             ::std::clone::Clone::clone(&(*__self_0_4)),},
        }
    }
}
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),}];
}