add

Author: zhuxiujia

.idea/.gitignore

@@ -0,0 +1,27 @@
+[package]
+name = "rbs"
+version = "4.5.27"
+edition = "2021"
+description = "Serialization framework for ORM"
+readme = "Readme.md"
+authors = ["ce <zhuxiujia@qq.com>"]
+license = "Apache-2.0"
+categories = ["database"]
+keywords = ["database", "orm", "mysql", "postgres", "sqlite"]
+documentation = "https://rbatis.github.io/rbatis.io"
+repository = "https://github.com/rbatis/rbatis"
+homepage = "https://rbatis.github.io/rbatis.io"
+
+
+[features]
+default = []
+#debug_mode will can see MapDeserializer key
+debug_mode = []
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+indexmap = "2.5"
+
+
+

Cargo.toml

@@ -0,0 +1,22 @@
+# rbs
+
+* rbs is rbatis's impl serde serialize trait crates.
+* The rbs serialization framework is used to serialize parameters and deserialize sql result sets, and provides the value structure as py_ Sql and html_ The intermediate object representation of the expression in sql.
+
+## use example
+```rust
+use std::collections::HashMap;
+fn main(){
+    #[derive(serde::Serialize, serde::Deserialize, Debug)]
+    pub struct A {
+        pub name: String,
+    }
+    let a = A {
+        name: "sss".to_string(),
+    };
+    let v = rbs::to_value(a).unwrap();
+    println!("v: {}",v);
+    let s: A = rbs::from_value(v).unwrap();
+    println!("s:{:?}", s);
+}
+```

README.md

@@ -0,0 +1,106 @@
+use serde::{ser, Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
+use std::num::{ParseFloatError, ParseIntError, TryFromIntError};
+use std::str::Utf8Error;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Error {
+    E(String),
+}
+
+impl Error {
+    pub fn append(self, arg: &str) -> Error {
+        match self {
+            Error::E(mut e) => {
+                e.push_str(arg);
+                Error::E(e)
+            }
+        }
+    }
+}
+
+impl Error {
+    #[allow(dead_code)]
+    #[inline]
+    pub fn protocol(err: impl Display) -> Self {
+        Error::from(format!("ProtocolError {}", err))
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::E(e) => std::fmt::Display::fmt(&e, f),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::E(format!("{}", msg))
+    }
+}
+
+impl serde::de::Error for Error {
+    #[cold]
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::E(format!("{}", msg))
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(arg: std::io::Error) -> Self {
+        Error::from(arg.to_string())
+    }
+}
+
+impl From<std::str::Utf8Error> for Error {
+    fn from(e: Utf8Error) -> Self {
+        Error::from(e.to_string())
+    }
+}
+
+impl From<&str> for Error {
+    fn from(arg: &str) -> Self {
+        Error::from(arg.to_string())
+    }
+}
+
+impl From<String> for Error {
+    fn from(arg: String) -> Self {
+        Error::E(arg)
+    }
+}
+
+impl From<ParseIntError> for Error {
+    fn from(arg: ParseIntError) -> Self {
+        Error::from(arg.to_string())
+    }
+}
+
+impl From<ParseFloatError> for Error {
+    fn from(arg: ParseFloatError) -> Self {
+        Error::from(arg.to_string())
+    }
+}
+
+impl From<TryFromIntError> for Error {
+    fn from(e: TryFromIntError) -> Self {
+        Error::from(e.to_string())
+    }
+}
+
+
+// Format an error message as a `Protocol` error
+#[macro_export]
+macro_rules! err_protocol {
+    ($expr:expr) => {
+        $crate::Error::E($expr.into())
+    };
+
+    ($fmt:expr, $($arg:tt)*) => {
+        $crate::Error::E(format!($fmt, $($arg)*))
+    };
+}

Readme.md

@@ -0,0 +1,200 @@
+use crate::Value;
+use std::ops::{Index, IndexMut};
+
+impl Index<usize> for Value {
+    type Output = Value;
+
+    fn index(&self, index: usize) -> &Value {
+        match self {
+            Value::Array(arr) => &arr[index],
+            Value::Ext(_, ext) => {
+                return ext.index(index);
+            }
+            _ => &Value::Null,
+        }
+    }
+}
+
+impl IndexMut<usize> for Value {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        match self {
+            Value::Array(arr) => &mut arr[index],
+            Value::Ext(_, ext) => {
+                return ext.index_mut(index);
+            }
+            _ => {
+                panic!("not an array!")
+            }
+        }
+    }
+}
+
+impl Index<&str> for Value {
+    type Output = Value;
+    fn index(&self, index: &str) -> &Self::Output {
+        match self {
+            Value::Map(m) => {
+                m.index(index)
+            }
+            Value::Ext(_, ext) => {
+                ext.index(index)
+            }
+            _ => {
+                &Value::Null
+            }
+        }
+    }
+}
+
+impl IndexMut<&str> for Value {
+    fn index_mut(&mut self, index: &str) -> &mut Self::Output {
+        match self {
+            Value::Map(m) => m.index_mut(index),
+            Value::Ext(_, ext) => {
+                return ext.index_mut(index);
+            }
+            _ => {
+                panic!("not map type")
+            }
+        }
+    }
+}
+
+
+impl Index<Value> for Value {
+    type Output = Value;
+
+    fn index(&self, index: Value) -> &Self::Output {
+        return match self {
+            Value::Array(arr) => {
+                let idx = index.as_u64().unwrap_or_default() as usize;
+                arr.index(idx)
+            }
+            Value::Map(map) => {
+                let s = index.as_str().unwrap_or_default();
+                map.index(s)
+            }
+            Value::Ext(_, ext) => {
+                ext.index(index)
+            }
+            _ => {
+                &Value::Null
+            }
+        };
+    }
+}
+
+
+impl Index<&Value> for Value {
+    type Output = Value;
+
+    fn index(&self, index: &Value) -> &Self::Output {
+        return match self {
+            Value::Array(arr) => {
+                let idx = index.as_u64().unwrap_or_default() as usize;
+                arr.index(idx)
+            }
+            Value::Map(map) => {
+                let s = index.as_str().unwrap_or_default();
+                map.index(s)
+            }
+            Value::Ext(_, ext) => {
+                ext.index(index)
+            }
+            _ => {
+                &Value::Null
+            }
+        };
+    }
+}
+
+
+impl IndexMut<Value> for Value {
+    fn index_mut(&mut self, index: Value) -> &mut Self::Output {
+        match self {
+            Value::Array(arr) => {
+                let idx = index.as_u64().unwrap_or_default() as usize;
+                arr.index_mut(idx)
+            }
+            Value::Map(map) => {
+                let s = index.as_str().unwrap_or_default();
+                map.index_mut(s)
+            }
+            Value::Ext(_, ext) => {
+                ext.index_mut(index)
+            }
+            _ => {
+                panic!("not map/array type")
+            }
+        }
+    }
+}
+
+
+impl IndexMut<&Value> for Value {
+    fn index_mut(&mut self, index: &Value) -> &mut Self::Output {
+        match self {
+            Value::Array(arr) => {
+                let idx = index.as_u64().unwrap_or_default() as usize;
+                arr.index_mut(idx)
+            }
+            Value::Map(map) => {
+                let s = index.as_str().unwrap_or_default();
+                map.index_mut(s)
+            }
+            Value::Ext(_, ext) => {
+                ext.index_mut(index)
+            }
+            _ => {
+                panic!("not map/array type")
+            }
+        }
+    }
+}
+
+impl Value {
+    pub fn insert(&mut self, key: Value, value: Value) -> Option<Value> {
+        match self {
+            Value::Null => None,
+            Value::Bool(_) => None,
+            Value::I32(_) => None,
+            Value::I64(_) => None,
+            Value::U32(_) => None,
+            Value::U64(_) => None,
+            Value::F32(_) => None,
+            Value::F64(_) => None,
+            Value::String(_) => None,
+            Value::Binary(_) => None,
+            Value::Array(arr) => {
+                arr.insert(key.as_u64().unwrap_or_default() as usize, value);
+                None
+            }
+            Value::Map(m) => m.insert(key, value),
+            Value::Ext(_, m) => m.insert(key, value),
+        }
+    }
+
+    pub fn remove(&mut self, key: &Value) -> Value {
+        match self {
+            Value::Null => Value::Null,
+            Value::Bool(_) => Value::Null,
+            Value::I32(_) => Value::Null,
+            Value::I64(_) => Value::Null,
+            Value::U32(_) => Value::Null,
+            Value::U64(_) => Value::Null,
+            Value::F32(_) => Value::Null,
+            Value::F64(_) => Value::Null,
+            Value::String(_) => Value::Null,
+            Value::Binary(_) => Value::Null,
+            Value::Array(arr) => {
+                let index = key.as_u64().unwrap_or_default() as usize;
+                if index >= arr.len() {
+                    return Value::Null;
+                }
+                arr.remove(index)
+            }
+            Value::Map(m) => m.remove(key),
+            Value::Ext(_, e) => e.remove(key),
+        }
+    }
+}