Implement SizedString type (#198)

* Implement SizedString type
* Update SizedString for example
* Add macro to write down the field for SizedString

Author: yanganto

examples/rdb-contract/src/lib.rs

@@ -141,7 +141,7 @@ fn main() -> anyhow::Result<sewup::primitives::EwasmAny> {
 #[ewasm_test]
 mod tests {
     use super::*;
-    use sewup::types::Raw;
+    use sewup::types::{Raw, SizedString};
     use sewup_derive::{ewasm_assert_eq, ewasm_assert_ok, ewasm_auto_assert_eq, ewasm_err_output};
 
     #[ewasm_test]
@@ -155,12 +155,11 @@ mod tests {
         let mut expect_output = create_input.clone();
         expect_output.set_id(1);
         ewasm_auto_assert_eq!(person::create(create_input), expect_output);
-
+        let s = SizedString::new(50)
+            .from_str("No Day but today, Embrace who you are.")
+            .unwrap();
         let post = Post {
-            content: [
-                sewup::types::Raw::from("No Day but today"),
-                sewup::types::Raw::from("Embrace who you are"),
-            ],
+            content: s.into(),
             person_id: 1,
         };
         let mut create_post_input = post::protocol(post);

examples/rdb-contract/src/modules.rs

@@ -1,6 +1,6 @@
 use serde_derive::{Deserialize, Serialize};
 use sewup::types::Raw;
-use sewup_derive::Table;
+use sewup_derive::{SizedString, Table};
 
 // Table derive provides the handers for CRUD,
 // to communicate with these handler, you will need protocol.
@@ -15,8 +15,7 @@ pub struct Person {
 #[derive(Table, Default, Clone, PartialEq, Serialize, Deserialize)]
 #[belongs_to(Person)]
 pub struct Post {
-    // Use the fix size Raw to save the content
-    pub content: [Raw; 2],
+    pub content: SizedString!(50),
 
     // Currently, this field need to set up manually, this will be enhance later
     pub person_id: usize,

sewup-derive/src/lib.rs

@@ -1409,3 +1409,27 @@ pub fn ewasm_err_output(item: TokenStream) -> TokenStream {
         .parse()
         .unwrap()
 }
+
+/// help you write the field which storage string no longer than the specific size
+///```compile_fail
+///#[derive(Table)]
+///pub struct Blog {
+///     pub content: SizedString!(50),
+///}
+///```
+#[allow(non_snake_case)]
+#[proc_macro_error]
+#[proc_macro]
+pub fn SizedString(item: TokenStream) -> TokenStream {
+    let num = item.to_string();
+
+    if let Ok(num) = num.trim().parse::<usize>() {
+        if num > 0 {
+            let raw_size = num / 32usize + 1;
+            return format!("[sewup::types::Raw; {}]", raw_size)
+                .parse()
+                .unwrap();
+        }
+    }
+    panic!("The input of SizedString! should be a greator than zero integer")
+}

sewup-derive/tests/unsupport-compile-pass/sized_string.rs

@@ -0,0 +1,10 @@
+// This test case need following issue support
+// https://github.com/dtolnay/trybuild/issues/108
+use sewup_derive::{SizedString, Table};
+
+#[derive(Table)]
+struct Blog {
+    content: SizedString!(50),
+}
+
+fn main() {}

sewup/src/types/errors.rs

@@ -0,0 +1,7 @@
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum TypeError {
+    #[error("data size excess the limitation `{0}`")]
+    SizeExcess(usize),
+}

sewup/src/types/mod.rs

@@ -1,6 +1,7 @@
 //! Sewup using Raw and Row as basic unit to storage the data
 //! - `Raw` is the storage unit in the contract, which contains 32 bytes.
 //! - `Row` is the list structure of `Raw`
+//! - `SizedString` is a structure to storage String with fixed number of Row
 //!
 //! It is easy to convert following types into `Raw` or `Row`:
 //! `str`, `&str`, `String`, `&String`, `Vec<u8>`, `[u8]`, `Address`, unsigned integer types
@@ -13,3 +14,7 @@ pub use raw::*;
 
 mod row;
 pub use row::*;
+
+pub mod errors;
+pub mod sized_str;
+pub use sized_str::*;

sewup/src/types/raw.rs

@@ -13,7 +13,7 @@ use crate::types::*;
 use ewasm_api::types::Address;
 
 /// The storage unit in the contract, which contains 32 bytes
-#[derive(Clone)]
+#[derive(Clone, Copy)]
 pub struct Raw {
     pub(crate) bytes: [u8; 32],
     // TODO: design a feature using the flag to write only needed

sewup/src/types/sized_str.rs

@@ -0,0 +1,86 @@
+use serde_derive::{Deserialize, Serialize};
+
+use anyhow::Result;
+
+use crate::types::*;
+
+/// SizedString is a type help you store string in with a predefined size
+/// ```
+/// let ss = sewup::types::sized_str::SizedString::new(10).from_str("hello").unwrap();
+/// assert!(ss.len() == 5);
+/// assert!(ss.capacity() == 10);
+/// assert_eq!(ss.to_utf8_string().unwrap(), "hello");
+/// ```
+#[derive(Clone, Serialize, Deserialize)]
+pub struct SizedString {
+    /// The size of bytes limited
+    pub capacity: usize,
+    pub len: usize,
+    inner: Vec<Raw>,
+}
+
+impl SizedString {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            capacity,
+            len: 0,
+            inner: Vec::<Raw>::with_capacity(capacity / 32usize + 1),
+        }
+    }
+    pub fn from_bytes(mut self, slice: &[u8]) -> Result<Self> {
+        if slice.len() > self.capacity {
+            return Err(errors::TypeError::SizeExcess(self.capacity).into());
+        }
+        self.len = slice.len();
+        self.inner = slice.iter().copied().collect::<Vec<u8>>().chunks(32).fold(
+            Vec::<Raw>::new(),
+            |mut vec, chunk| {
+                vec.push(chunk.into());
+                vec
+            },
+        );
+        for _ in 0..(self.capacity / 32usize) - (self.len / 32usize) {
+            self.inner.push(Raw::default());
+        }
+        Ok(self)
+    }
+
+    pub fn from_str(self, s: &str) -> Result<Self> {
+        self.from_bytes(s.as_bytes())
+    }
+
+    pub fn to_utf8_string(&self) -> Result<String> {
+        let buf = self.inner.iter().fold(Vec::<u8>::new(), |mut vec, raw| {
+            vec.extend_from_slice(raw.as_ref());
+            vec
+        });
+        String::from_utf8(buf[0..self.len].to_vec()).map_err(|e| e.into())
+    }
+
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+}
+
+macro_rules! into_slice {
+    ($($s:expr),*) => {
+        $(
+            impl Into<[Raw; $s]> for SizedString {
+                fn into(self) -> [Raw; $s] {
+                    let mut output = Default::default();
+                    <[Raw; $s] as AsMut<[Raw]>>::as_mut(&mut output).copy_from_slice(self.inner.as_slice());
+                    output
+                }
+            }
+        )*
+    }
+}
+
+into_slice!(
+    0, 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
+);