more parsing helpers

1 files changed, 125 insertions, 0 deletions

diff --git a/src/object/helper.rs b/src/object/helper.rs
new file mode 100644
index 0000000..3f41703
--- /dev/null
+++ b/src/object/helper.rs
@@ -0,0 +1,125 @@
+use super::Value;
+
+impl Value {
+    pub fn class_name(&self) -> Option<&String> {
+        if let Value::Object { class, .. } = self {
+            Some(class)
+        } else {
+            None
+        }
+    }
+    pub fn as_string(self) -> Option<String> {
+        if let Value::String(s) = self {
+            Some(s)
+        } else {
+            None
+        }
+    }
+    pub fn as_i64(&self) -> Option<i64> {
+        if let Value::I64(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_i32(&self) -> Option<i32> {
+        if let Value::I32(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_u32(&self) -> Option<u32> {
+        if let Value::U32(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_u8(&self) -> Option<u8> {
+        if let Value::U8(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_u64(&self) -> Option<u64> {
+        match self {
+            Self::U64(x) => Some(*x),
+            Self::U32(x) => Some(*x as u64),
+            _ => None,
+        }
+    }
+    pub fn as_f32(&self) -> Option<f32> {
+        if let Value::F32(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_u16(&self) -> Option<u16> {
+        if let Value::U16(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_bool(&self) -> Option<bool> {
+        if let Value::Bool(s) = self {
+            Some(*s)
+        } else {
+            None
+        }
+    }
+    pub fn as_array(self) -> Option<Vec<Value>> {
+        if let Value::Array(s) = self {
+            Some(s)
+        } else {
+            None
+        }
+    }
+    pub fn as_typeless(self) -> Option<Vec<u8>> {
+        if let Value::Typeless(s) = self {
+            Some(s)
+        } else {
+            None
+        }
+    }
+    pub fn to_json(self) -> serde_json::Value {
+        match self {
+            Value::Bool(x) => serde_json::Value::Bool(x),
+            Value::U8(x) => serde_json::Value::Number(x.into()),
+            Value::I8(x) => serde_json::Value::Number(x.into()),
+            Value::U16(x) => serde_json::Value::Number(x.into()),
+            Value::I16(x) => serde_json::Value::Number(x.into()),
+            Value::U32(x) => serde_json::Value::Number(x.into()),
+            Value::U64(x) => serde_json::Value::Number(x.into()),
+            Value::I32(x) => serde_json::Value::Number(x.into()),
+            Value::F32(x) => serde_json::Value::Number(
+                serde_json::Number::from_f64(x as f64).unwrap_or(0.into()),
+            ),
+            Value::I64(x) => serde_json::Value::Number(x.into()),
+            Value::F64(x) => serde_json::Value::Number(serde_json::Number::from_f64(x).unwrap()),
+            Value::String(x) => serde_json::Value::String(x),
+            Value::Typeless(values) => serde_json::Value::Array(
+                values
+                    .into_iter()
+                    .map(|e| serde_json::Value::Number(e.into()))
+                    .collect(),
+            ),
+            Value::Array(values) => {
+                serde_json::Value::Array(values.into_iter().map(Value::to_json).collect())
+            }
+            Value::Object { class, fields } => serde_json::Value::Object(
+                fields
+                    .into_iter()
+                    .map(|(k, v)| (k, v.to_json()))
+                    .chain(Some((
+                        "@class".to_string(),
+                        serde_json::Value::String(class),
+                    )))
+                    .collect(),
+            ),
+        }
+    }
+}