    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334

    //! # Serde
    //!
    //! Serde is a framework for ***ser***ializing and ***de***serializing Rust data
    //! structures efficiently and generically.
    //!
    //! The Serde ecosystem consists of data structures that know how to serialize
    //! and deserialize themselves along with data formats that know how to
    //! serialize and deserialize other things. Serde provides the layer by which
    //! these two groups interact with each other, allowing any supported data
    //! structure to be serialized and deserialized using any supported data format.
    //!
    //! See the Serde website <https://serde.rs/> for additional documentation and
    //! usage examples.
    //!
    //! ## Design
    //!
    //! Where many other languages rely on runtime reflection for serializing data,
    //! Serde is instead built on Rust's powerful trait system. A data structure
    //! that knows how to serialize and deserialize itself is one that implements
    //! Serde's `Serialize` and `Deserialize` traits (or uses Serde's derive
    //! attribute to automatically generate implementations at compile time). This
    //! avoids any overhead of reflection or runtime type information. In fact in
    //! many situations the interaction between data structure and data format can
    //! be completely optimized away by the Rust compiler, leaving Serde
    //! serialization to perform the same speed as a handwritten serializer for the
    //! specific selection of data structure and data format.
    //!
    //! ## Data formats
    //!
    //! The following is a partial list of data formats that have been implemented
    //! for Serde by the community.
    //!
    //! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.
    //! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
    //! - [CBOR], a Concise Binary Object Representation designed for small message
    //!   size without the need for version negotiation.
    //! - [YAML], a self-proclaimed human-friendly configuration language that ain't
    //!   markup language.
    //! - [MessagePack], an efficient binary format that resembles a compact JSON.
    //! - [TOML], a minimal configuration format used by [Cargo].
    //! - [Pickle], a format common in the Python world.
    //! - [RON], a Rusty Object Notation.
    //! - [BSON], the data storage and network transfer format used by MongoDB.
    //! - [Avro], a binary format used within Apache Hadoop, with support for schema
    //!   definition.
    //! - [JSON5], a superset of JSON including some productions from ES5.
    //! - [URL] query strings, in the x-www-form-urlencoded format.
    //! - [Envy], a way to deserialize environment variables into Rust structs.
    //!   *(deserialization only)*
    //! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
    //!   Rust structs. *(deserialization only)*
    //! - [S-expressions], the textual representation of code and data used by the
    //!   Lisp language family.
    //! - [D-Bus]'s binary wire format.
    //! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy
    //!   serialization format.
    //! - [Bencode], a simple binary format used in the BitTorrent protocol.
    //! - [Token streams], for processing Rust procedural macro input.
    //!   *(deserialization only)*
    //! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
    //!   and from DynamoDB.
    //! - [Hjson], a syntax extension to JSON designed around human reading and
    //!   editing. *(deserialization only)*
    //!
    //! [JSON]: https://github.com/serde-rs/json
    //! [Postcard]: https://github.com/jamesmunns/postcard
    //! [CBOR]: https://github.com/enarx/ciborium
    //! [YAML]: https://github.com/dtolnay/serde-yaml
    //! [MessagePack]: https://github.com/3Hren/msgpack-rust
    //! [TOML]: https://docs.rs/toml
    //! [Pickle]: https://github.com/birkenfeld/serde-pickle
    //! [RON]: https://github.com/ron-rs/ron
    //! [BSON]: https://github.com/mongodb/bson-rust
    //! [Avro]: https://docs.rs/apache-avro
    //! [JSON5]: https://github.com/callum-oakley/json5-rs
    //! [URL]: https://docs.rs/serde_qs
    //! [Envy]: https://github.com/softprops/envy
    //! [Envy Store]: https://github.com/softprops/envy-store
    //! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
    //! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
    //! [S-expressions]: https://github.com/rotty/lexpr-rs
    //! [D-Bus]: https://docs.rs/zvariant
    //! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
    //! [Bencode]: https://github.com/P3KI/bendy
    //! [Token streams]: https://github.com/oxidecomputer/serde_tokenstream
    //! [DynamoDB Items]: https://docs.rs/serde_dynamo
    //! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
    //! [Hjson]: https://github.com/Canop/deser-hjson

    ////////////////////////////////////////////////////////////////////////////////

    // Serde types in rustdoc of other crates get linked to here.
    #![doc(html_root_url = "https://docs.rs/serde/1.0.152")]
    // Support using Serde without the standard library!
    #![cfg_attr(not(feature = "std"), no_std)]
    // Unstable functionality only if the user asks for it. For tracking and
    // discussion of these features please refer to this issue:
    //
    //    https://github.com/serde-rs/serde/issues/812
    #![cfg_attr(feature = "unstable", feature(error_in_core, never_type))]
    #![allow(unknown_lints, bare_trait_objects, deprecated)]
    #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
    // Ignored clippy and clippy_pedantic lints
    #![cfg_attr(
        feature = "cargo-clippy",
        allow(
            // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
            unnested_or_patterns,
            // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
            semicolon_if_nothing_returned,
            // not available in our oldest supported compiler
            empty_enum,
            type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
            // integer and float ser/de requires these sorts of casts
            cast_possible_truncation,
            cast_possible_wrap,
            cast_sign_loss,
            // things are often more readable this way
            cast_lossless,
            module_name_repetitions,
            option_if_let_else,
            single_match_else,
            type_complexity,
            use_self,
            zero_prefixed_literal,
            // correctly used
            derive_partial_eq_without_eq,
            enum_glob_use,
            explicit_auto_deref,
            map_err_ignore,
            new_without_default,
            result_unit_err,
            wildcard_imports,
            // not practical
            needless_pass_by_value,
            similar_names,
            too_many_lines,
            // preference
            doc_markdown,
            unseparated_literal_suffix,
            // false positive
            needless_doctest_main,
            // noisy
            missing_errors_doc,
            must_use_candidate,
        )
    )]
    // Rustc lints.
    #![deny(missing_docs, unused_imports)]

    ////////////////////////////////////////////////////////////////////////////////

    #[cfg(feature = "alloc")]
    extern crate alloc;

    /// A facade around all the types we need from the `std`, `core`, and `alloc`
    /// crates. This avoids elaborate import wrangling having to happen in every
    /// module.
    mod lib {
        mod core {
            #[cfg(not(feature = "std"))]
            pub use core::*;
            #[cfg(feature = "std")]
            pub use std::*;
        }

        pub use self::core::{cmp, iter, mem, num, ptr, slice, str};
        pub use self::core::{f32, f64};
        pub use self::core::{i16, i32, i64, i8, isize};
        pub use self::core::{u16, u32, u64, u8, usize};

        pub use self::core::cell::{Cell, RefCell};
        pub use self::core::clone::{self, Clone};
        pub use self::core::convert::{self, From, Into};
        pub use self::core::default::{self, Default};
        pub use self::core::fmt::{self, Debug, Display};
        pub use self::core::marker::{self, PhantomData};
        pub use self::core::num::Wrapping;
        pub use self::core::ops::Range;
        pub use self::core::option::{self, Option};
        pub use self::core::result::{self, Result};

        #[cfg(all(feature = "alloc", not(feature = "std")))]
        pub use alloc::borrow::{Cow, ToOwned};
        #[cfg(feature = "std")]
        pub use std::borrow::{Cow, ToOwned};

        #[cfg(all(feature = "alloc", not(feature = "std")))]
        pub use alloc::string::{String, ToString};
        #[cfg(feature = "std")]
        pub use std::string::{String, ToString};

        #[cfg(all(feature = "alloc", not(feature = "std")))]
        pub use alloc::vec::Vec;
        #[cfg(feature = "std")]
        pub use std::vec::Vec;

        #[cfg(all(feature = "alloc", not(feature = "std")))]
        pub use alloc::boxed::Box;
        #[cfg(feature = "std")]
        pub use std::boxed::Box;

        #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
        pub use alloc::rc::{Rc, Weak as RcWeak};
        #[cfg(all(feature = "rc", feature = "std"))]
        pub use std::rc::{Rc, Weak as RcWeak};

        #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
        pub use alloc::sync::{Arc, Weak as ArcWeak};
        #[cfg(all(feature = "rc", feature = "std"))]
        pub use std::sync::{Arc, Weak as ArcWeak};

        #[cfg(all(feature = "alloc", not(feature = "std")))]
        pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
        #[cfg(feature = "std")]
        pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};

        #[cfg(feature = "std")]
        pub use std::{error, net};

        #[cfg(feature = "std")]
        pub use std::collections::{HashMap, HashSet};
        #[cfg(feature = "std")]
        pub use std::ffi::{CStr, CString, OsStr, OsString};
        #[cfg(feature = "std")]
        pub use std::hash::{BuildHasher, Hash};
        #[cfg(feature = "std")]
        pub use std::io::Write;
        #[cfg(feature = "std")]
        pub use std::path::{Path, PathBuf};
        #[cfg(feature = "std")]
        pub use std::sync::{Mutex, RwLock};
        #[cfg(feature = "std")]
        pub use std::time::{SystemTime, UNIX_EPOCH};

        #[cfg(all(feature = "std", not(no_collections_bound), no_ops_bound))]
        pub use std::collections::Bound;

        #[cfg(not(no_core_reverse))]
        pub use self::core::cmp::Reverse;

        #[cfg(not(no_ops_bound))]
        pub use self::core::ops::Bound;

        #[cfg(not(no_range_inclusive))]
        pub use self::core::ops::RangeInclusive;

        #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic)))]
        pub use std::sync::atomic::{
            AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
            AtomicUsize, Ordering,
        };
        #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic64)))]
        pub use std::sync::atomic::{AtomicI64, AtomicU64};

        #[cfg(all(feature = "std", not(no_target_has_atomic)))]
        pub use std::sync::atomic::Ordering;
        #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "8"))]
        pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
        #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "16"))]
        pub use std::sync::atomic::{AtomicI16, AtomicU16};
        #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "32"))]
        pub use std::sync::atomic::{AtomicI32, AtomicU32};
        #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "64"))]
        pub use std::sync::atomic::{AtomicI64, AtomicU64};
        #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))]
        pub use std::sync::atomic::{AtomicIsize, AtomicUsize};

        #[cfg(any(feature = "std", not(no_core_duration)))]
        pub use self::core::time::Duration;
    }

    // None of this crate's error handling needs the `From::from` error conversion
    // performed implicitly by the `?` operator or the standard library's `try!`
    // macro. This simplified macro gives a 5.5% improvement in compile time
    // compared to standard `try!`, and 9% improvement compared to `?`.
    macro_rules! try {
        ($expr:expr) => {
            match $expr {
                Ok(val) => val,
                Err(err) => return Err(err),
            }
        };
    }

    ////////////////////////////////////////////////////////////////////////////////

    #[macro_use]
    mod macros;

    #[macro_use]
    mod integer128;

    pub mod de;
    pub mod ser;

    #[doc(inline)]
    pub use de::{Deserialize, Deserializer};
    #[doc(inline)]
    pub use ser::{Serialize, Serializer};

    // Used by generated code and doc tests. Not public API.
    #[doc(hidden)]
    #[path = "private/mod.rs"]
    pub mod __private;

    #[allow(unused_imports)]
    use self::__private as export;
    #[allow(unused_imports)]
    use self::__private as private;

    #[path = "de/seed.rs"]
    mod seed;

    #[cfg(not(any(feature = "std", feature = "unstable")))]
    mod std_error;

    // Re-export #[derive(Serialize, Deserialize)].
    //
    // The reason re-exporting is not enabled by default is that disabling it would
    // be annoying for crates that provide handwritten impls or data formats. They
    // would need to disable default features and then explicitly re-enable std.
    #[cfg(feature = "serde_derive")]
    #[allow(unused_imports)]
    #[macro_use]
    extern crate serde_derive;
    #[cfg(feature = "serde_derive")]
    #[doc(hidden)]
    pub use serde_derive::*;

    #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
    mod actually_private {
        pub struct T;
    }