    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

    use super::Value;
    use crate::map::Map;
    use alloc::borrow::ToOwned;
    use alloc::string::String;
    use core::fmt::{self, Display};
    use core::ops;

    /// A type that can be used to index into a `serde_json::Value`.
    ///
    /// The [`get`] and [`get_mut`] methods of `Value` accept any type that
    /// implements `Index`, as does the [square-bracket indexing operator]. This
    /// trait is implemented for strings which are used as the index into a JSON
    /// map, and for `usize` which is used as the index into a JSON array.
    ///
    /// [`get`]: ../enum.Value.html#method.get
    /// [`get_mut`]: ../enum.Value.html#method.get_mut
    /// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E
    ///
    /// This trait is sealed and cannot be implemented for types outside of
    /// `serde_json`.
    ///
    /// # Examples
    ///
    /// ```
    /// # use serde_json::json;
    /// #
    /// let data = json!({ "inner": [1, 2, 3] });
    ///
    /// // Data is a JSON map so it can be indexed with a string.
    /// let inner = &data["inner"];
    ///
    /// // Inner is a JSON array so it can be indexed with an integer.
    /// let first = &inner[0];
    ///
    /// assert_eq!(first, 1);
    /// ```
    pub trait Index: private::Sealed {
        /// Return None if the key is not already in the array or object.
        #[doc(hidden)]
        fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;

        /// Return None if the key is not already in the array or object.
        #[doc(hidden)]
        fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;

        /// Panic if array index out of bounds. If key is not already in the object,
        /// insert it with a value of null. Panic if Value is a type that cannot be
        /// indexed into, except if Value is null then it can be treated as an empty
        /// object.
        #[doc(hidden)]
        fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
    }

    impl Index for usize {
        fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
            match v {
                Value::Array(vec) => vec.get(*self),
                _ => None,
            }
        }
        fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
            match v {
                Value::Array(vec) => vec.get_mut(*self),
                _ => None,
            }
        }
        fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
            match v {
                Value::Array(vec) => {
                    let len = vec.len();
                    vec.get_mut(*self).unwrap_or_else(|| {
                        panic!(
                            "cannot access index {} of JSON array of length {}",
                            self, len
                        )
                    })
                }
                _ => panic!("cannot access index {} of JSON {}", self, Type(v)),
            }
        }
    }

    impl Index for str {
        fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
            match v {
                Value::Object(map) => map.get(self),
                _ => None,
            }
        }
        fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
            match v {
                Value::Object(map) => map.get_mut(self),
                _ => None,
            }
        }
        fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
            if let Value::Null = v {
                *v = Value::Object(Map::new());
            }
            match v {
                Value::Object(map) => map.entry(self.to_owned()).or_insert(Value::Null),
                _ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
            }
        }
    }

    impl Index for String {
        fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
            self[..].index_into(v)
        }
        fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
            self[..].index_into_mut(v)
        }
        fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
            self[..].index_or_insert(v)
        }
    }

    impl<'a, T> Index for &'a T
    where
        T: ?Sized + Index,
    {
        fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
            (**self).index_into(v)
        }
        fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
            (**self).index_into_mut(v)
        }
        fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
            (**self).index_or_insert(v)
        }
    }

    // Prevent users from implementing the Index trait.
    mod private {
        pub trait Sealed {}
        impl Sealed for usize {}
        impl Sealed for str {}
        impl Sealed for alloc::string::String {}
        impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}
    }

    /// Used in panic messages.
    struct Type<'a>(&'a Value);

    impl<'a> Display for Type<'a> {
        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            match *self.0 {
                Value::Null => formatter.write_str("null"),
                Value::Bool(_) => formatter.write_str("boolean"),
                Value::Number(_) => formatter.write_str("number"),
                Value::String(_) => formatter.write_str("string"),
                Value::Array(_) => formatter.write_str("array"),
                Value::Object(_) => formatter.write_str("object"),
            }
        }
    }

    // The usual semantics of Index is to panic on invalid indexing.
    //
    // That said, the usual semantics are for things like Vec and BTreeMap which
    // have different use cases than Value. If you are working with a Vec, you know
    // that you are working with a Vec and you can get the len of the Vec and make
    // sure your indices are within bounds. The Value use cases are more
    // loosey-goosey. You got some JSON from an endpoint and you want to pull values
    // out of it. Outside of this Index impl, you already have the option of using
    // value.as_array() and working with the Vec directly, or matching on
    // Value::Array and getting the Vec directly. The Index impl means you can skip
    // that and index directly into the thing using a concise syntax. You don't have
    // to check the type, you don't have to check the len, it is all about what you
    // expect the Value to look like.
    //
    // Basically the use cases that would be well served by panicking here are
    // better served by using one of the other approaches: get and get_mut,
    // as_array, or match. The value of this impl is that it adds a way of working
    // with Value that is not well served by the existing approaches: concise and
    // careless and sometimes that is exactly what you want.
    impl<I> ops::Index<I> for Value
    where
        I: Index,
    {
        type Output = Value;

        /// Index into a `serde_json::Value` using the syntax `value[0]` or
        /// `value["k"]`.
        ///
        /// Returns `Value::Null` if the type of `self` does not match the type of
        /// the index, for example if the index is a string and `self` is an array
        /// or a number. Also returns `Value::Null` if the given key does not exist
        /// in the map or the given index is not within the bounds of the array.
        ///
        /// For retrieving deeply nested values, you should have a look at the
        /// `Value::pointer` method.
        ///
        /// # Examples
        ///
        /// ```
        /// # use serde_json::json;
        /// #
        /// let data = json!({
        ///     "x": {
        ///         "y": ["z", "zz"]
        ///     }
        /// });
        ///
        /// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
        /// assert_eq!(data["x"]["y"][0], json!("z"));
        ///
        /// assert_eq!(data["a"], json!(null)); // returns null for undefined values
        /// assert_eq!(data["a"]["b"], json!(null)); // does not panic
        /// ```
        fn index(&self, index: I) -> &Value {
            static NULL: Value = Value::Null;
            index.index_into(self).unwrap_or(&NULL)
        }
    }

    impl<I> ops::IndexMut<I> for Value
    where
        I: Index,
    {
        /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
        /// `value["k"] = ...`.
        ///
        /// If the index is a number, the value must be an array of length bigger
        /// than the index. Indexing into a value that is not an array or an array
        /// that is too small will panic.
        ///
        /// If the index is a string, the value must be an object or null which is
        /// treated like an empty object. If the key is not already present in the
        /// object, it will be inserted with a value of null. Indexing into a value
        /// that is neither an object nor null will panic.
        ///
        /// # Examples
        ///
        /// ```
        /// # use serde_json::json;
        /// #
        /// let mut data = json!({ "x": 0 });
        ///
        /// // replace an existing key
        /// data["x"] = json!(1);
        ///
        /// // insert a new key
        /// data["y"] = json!([false, false, false]);
        ///
        /// // replace an array value
        /// data["y"][0] = json!(true);
        ///
        /// // inserted a deeply nested key
        /// data["a"]["b"]["c"]["d"] = json!(true);
        ///
        /// println!("{}", data);
        /// ```
        fn index_mut(&mut self, index: I) -> &mut Value {
            index.index_or_insert(self)
        }
    }