Add enum RawKind and is_* to RawValue

Author: bheylin

src/raw.rs

@@ -227,6 +227,149 @@ impl RawValue {
     pub fn get(&self) -> &str {
         &self.json
     }
+
+    /// Returns the kind of JSON value contained within.
+    fn kind(&self) -> RawKind {
+        let first = self
+            .json
+            .as_bytes()
+            .first()
+            .expect("The `str` contained in `RawValue` can`t be an empty");
+
+        // `RawValue` has whitespace stripped so we know the first char is non-whitespace.
+        // `RawValue` is also valid JSON so the only possible set of chars that can come next
+        // are `[0-9]` or `[-fnt"[{]`.
+        match *first {
+            b'n' => RawKind::Null,
+            b't' | b'f' => RawKind::Bool,
+            b'"' => RawKind::String,
+            b'[' => RawKind::Array,
+            b'{' => RawKind::Object,
+            // A `RawValue` is already known to be valid, the only other possibility for
+            // valid JSON is that this is a number
+            _ => RawKind::Number,
+        }
+    }
+
+    /// Returns true if the `Value` is a Null. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let v = json!({ "a": null, "b": false });
+    /// let v = serde_json::value::to_raw_value(v).unwrap();
+    ///
+    /// assert!(v["a"].is_null());
+    ///
+    /// // The boolean `false` is not null.
+    /// assert!(!v["b"].is_null());
+    /// ```
+    fn is_null(&self) -> bool {
+        matches!(self.kind(), RawKind::Null)
+    }
+
+    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let v = json!({ "a": false, "b": "false" });
+    /// let v = serde_json::value::to_raw_value(v).unwrap();
+    ///
+    /// assert!(v["a"].is_boolean());
+    ///
+    /// // The string `"false"` is a string, not a boolean.
+    /// assert!(!v["b"].is_boolean());
+    /// ```
+    fn is_boolean(&self) -> bool {
+        matches!(self.kind(), RawKind::Bool)
+    }
+
+    /// Returns true if the `Value` is a Number. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let v = json!({ "a": 1, "b": "2" });
+    /// let v = serde_json::value::to_raw_value(v).unwrap();
+    ///
+    /// assert!(v["a"].is_number());
+    ///
+    /// // The string `"2"` is a string, not a number.
+    /// assert!(!v["b"].is_number());
+    /// ```
+    fn is_number(&self) -> bool {
+        matches!(self.kind(), RawKind::Number)
+    }
+
+    /// Returns true if the `Value` is a String. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let v = json!({ "a": "some string", "b": false });
+    /// let v = serde_json::value::to_raw_value(v).unwrap();
+    ///
+    /// assert!(v["a"].is_string());
+    ///
+    /// // The boolean `false` is not a string.
+    /// assert!(!v["b"].is_string());
+    /// ```
+    fn is_string(&self) -> bool {
+        matches!(self.kind(), RawKind::String)
+    }
+
+    /// Returns true if the `Value` is an Array. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });
+    /// let obj = serde_json::value::to_raw_value(obj).unwrap();
+    ///
+    /// assert!(obj["a"].is_array());
+    ///
+    /// // an object, not an array
+    /// assert!(!obj["b"].is_array());
+    /// ```
+    fn is_array(&self) -> bool {
+        matches!(self.kind(), RawKind::Array)
+    }
+
+    /// Returns true if the `Value` is an Object. Returns false otherwise.
+    ///
+    /// ```
+    /// # use serde_json::json;
+    /// #
+    /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });
+    /// let obj = serde_json::value::to_raw_value(obj).unwrap();
+    ///
+    /// assert!(obj.is_object());
+    /// assert!(obj["a"].is_object());
+    ///
+    /// // array, not an object
+    /// assert!(!obj["b"].is_object());
+    /// ```
+    fn is_object(&self) -> bool {
+        matches!(self.kind(), RawKind::Object)
+    }
+}
+
+// A kind of JSON value the `RawValue` contains.
+#[derive(Debug, Copy, Clone)]
+pub enum RawKind {
+    /// Represents a JSON null value.
+    Null,
+    /// Represents a JSON boolean.
+    Bool,
+    /// Represents a JSON number, whether integer or floating point.
+    Number,
+    /// Represents a JSON string.
+    String,
+    /// Represents a JSON array.
+    Array,
+    /// Represents a JSON object.
+    Object,
 }
 
 impl From<Box<RawValue>> for Box<str> {