Add package metadata

Signed-off-by: trivernis <trivernis@protonmail.com>

Cargo.toml

@@ -5,6 +5,10 @@ members = [".", "derive"]
 name = "rusty-value"
 version = "0.1.0"
 edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/Trivernis/rusty-value"
+description = "Create a generic inspectable value from any rust type"
+authors = ["trivernis <trivernis@proton.me>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

README.md

@@ -0,0 +1,5 @@
+# Rusty Value
+
+This crate adds a `RustyValue` trait that can be derived for all types (except unions)
+to create a generic value that represents a rust value.
+This can be used to implement serialization of types without having to rely on serde.

derive/Cargo.toml

@@ -2,6 +2,10 @@
 name = "rusty-value-derive"
 version = "0.1.0"
 edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/Trivernis/rusty-value"
+description = "Derive implementaton for rusty-value"
+authors = ["trivernis <trivernis@proton.me>"]
 
 [lib]
 proc-macro = true

src/value.rs

@@ -1,14 +1,17 @@
 use std::collections::HashMap;
 
+/// Represents a generic rust value
 #[derive(Clone, Debug, PartialEq)]
 pub enum Value {
     Primitive(Primitive),
     Struct(Struct),
     Enum(Enum),
-    Map(HashMap<HashablePrimitive, Value>),
+    Map(HashMap<HashableValue, Value>),
     List(Vec<Value>),
 }
 
+/// Represents an enum with a given variant
+/// And fields depending on that variant
 #[derive(Clone, Debug, PartialEq)]
 pub struct Enum {
     pub name: String,
@@ -16,12 +19,14 @@ pub struct Enum {
     pub fields: Fields,
 }
 
+/// Represents a struct with fields
 #[derive(Clone, Debug, PartialEq)]
 pub struct Struct {
     pub name: String,
     pub fields: Fields,
 }
 
+/// Fields of a struct or an enum that are either named, unnamed or not defined (Unit enums/structs)
 #[derive(Clone, Debug, PartialEq)]
 pub enum Fields {
     Named(HashMap<String, Value>),
@@ -29,6 +34,7 @@ pub enum Fields {
     Unit,
 }
 
+/// A rust primitive value
 #[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub enum Primitive {
     Integer(Integer),
@@ -38,8 +44,11 @@ pub enum Primitive {
     Bool(bool),
 }
 
+/// A primitive integer value
 #[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
 pub enum Integer {
+    USize(usize),
+    ISize(isize),
     U8(u8),
     I8(i8),
     U16(u16),
@@ -52,16 +61,21 @@ pub enum Integer {
     I128(i128),
 }
 
+/// A primitive float value
 #[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub enum Float {
     F32(f32),
     F64(f64),
 }
 
+/// A value that can be used as a key inside a hash map
+#[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
 pub enum HashableValue {
     Primitive(HashablePrimitive),
+    List(Vec<HashableValue>),
 }
 
+/// A primitive that can be used as a hash map key
 #[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
 pub enum HashablePrimitive {
     Integer(Integer),

src/value_trait.rs

@@ -1,80 +1,130 @@
 use std::collections::HashMap;
 
-use crate::{HashablePrimitive, Primitive, Value};
+use crate::{Float, HashablePrimitive, HashableValue, Primitive, Value};
 
 pub trait RustyValue {
     fn into_rusty_value(self) -> Value;
 }
 
-impl RustyValue for u8 {
+pub trait HashableRustyValue {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue;
-        Value::Primitive(Primitive::Integer(crate::Integer::U8(self)))
+}
+
+impl HashableRustyValue for usize {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::USize(self)))
     }
 }
 
-impl RustyValue for i8 {
+impl HashableRustyValue for isize {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::I8(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::ISize(self)))
     }
 }
 
-impl RustyValue for u16 {
+impl HashableRustyValue for u8 {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::U16(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::U8(self)))
     }
 }
 
-impl RustyValue for i16 {
+impl HashableRustyValue for i8 {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::I16(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::I8(self)))
     }
 }
 
-impl RustyValue for u32 {
+impl HashableRustyValue for u16 {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::U32(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::U16(self)))
     }
 }
 
-impl RustyValue for i32 {
+impl HashableRustyValue for i16 {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::I32(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::I16(self)))
     }
 }
 
-impl RustyValue for u64 {
+impl HashableRustyValue for u32 {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::U64(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::U32(self)))
     }
 }
 
-impl RustyValue for i64 {
+impl HashableRustyValue for i32 {
-    fn into_rusty_value(self) -> Value {
+    fn into_hashable_rusty_value(self) -> HashableValue {
-        Value::Primitive(Primitive::Integer(crate::Integer::I64(self)))
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::I32(self)))
+    }
+}
+
+impl HashableRustyValue for u64 {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::U64(self)))
+    }
+}
+
+impl HashableRustyValue for i64 {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::I64(self)))
+    }
+}
+
+impl HashableRustyValue for u128 {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::U128(self)))
     }
 }
 
-impl RustyValue for u128 {
+impl HashableRustyValue for i128 {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::Integer(crate::Integer::I128(self)))
+    }
+}
+
+impl HashableRustyValue for String {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::String(self))
+    }
+}
+
+impl HashableRustyValue for bool {
+    fn into_hashable_rusty_value(self) -> HashableValue {
+        HashableValue::Primitive(HashablePrimitive::Bool(self))
+    }
+}
+
+impl RustyValue for HashableValue {
     fn into_rusty_value(self) -> Value {
-        Value::Primitive(Primitive::Integer(crate::Integer::U128(self)))
+        match self {
+            HashableValue::Primitive(p) => match p {
+                HashablePrimitive::Integer(i) => Value::Primitive(Primitive::Integer(i)),
+                HashablePrimitive::String(s) => Value::Primitive(Primitive::String(s)),
+                HashablePrimitive::Char(c) => Value::Primitive(Primitive::Char(c)),
+                HashablePrimitive::Bool(b) => Value::Primitive(Primitive::Bool(b)),
+            },
+            HashableValue::List(l) => {
+                Value::List(l.into_iter().map(|v| v.into_rusty_value()).collect())
+            }
+        }
     }
 }
 
-impl RustyValue for i128 {
+impl<H: HashableRustyValue> RustyValue for H {
     fn into_rusty_value(self) -> Value {
-        Value::Primitive(Primitive::Integer(crate::Integer::I128(self)))
+        self.into_hashable_rusty_value().into_rusty_value()
     }
 }
 
-impl RustyValue for String {
+impl RustyValue for f32 {
     fn into_rusty_value(self) -> Value {
-        Value::Primitive(Primitive::String(self))
+        Value::Primitive(Primitive::Float(Float::F32(self)))
     }
 }
 
-impl RustyValue for bool {
+impl RustyValue for f64 {
     fn into_rusty_value(self) -> Value {
-        Value::Primitive(Primitive::Bool(self))
+        Value::Primitive(Primitive::Float(Float::F64(self)))
     }
 }
 
@@ -89,11 +139,11 @@ impl<R: RustyValue> RustyValue for Vec<R> {
     }
 }
 
-impl<R: RustyValue> RustyValue for HashMap<String, R> {
+impl<R: RustyValue, H: HashableRustyValue> RustyValue for HashMap<H, R> {
     fn into_rusty_value(self) -> Value {
         let map = self
             .into_iter()
-            .map(|(k, v)| (HashablePrimitive::String(k), v.into_rusty_value()))
+            .map(|(k, v)| (k.into_hashable_rusty_value(), v.into_rusty_value()))
             .collect::<HashMap<_, _>>();
 
         Value::Map(map)