the state before switching to dynamic dispatch for stores

src/core/error.rs

@@ -7,6 +7,11 @@ use std::io;
 use colored::Colorize;
 use log::{trace, debug, info, warn, error};
 
+#[macro_export]
+macro_rules! mize_err {
+    ($($arg:tt)*) => { MizeError::new().msg(format!( $($arg)*)) };
+}
+
 use crate::proto::MizeMessage;
 
 pub type MizeResult<T> = Result<T, MizeError>;

src/core/instance/mod.rs

@@ -130,7 +130,19 @@ impl<S: Store> Instance<S> {
     //fn from(value: T) -> Self {
     //}
 //}
+    pub fn migrate_to_store<New: Store>(&mut self, new_store: New) -> MizeResult<Instance<New>> {
+        let old_store = self.store;
 
+        for id in old_store.id_iter()? {
+            let data = self.store.get_value_data_full(self.id_from_string(id))?;
+
+            let id_of_new_store = new_store.new_id()?;
+            new_store.set(self.id_from_string(id_of_new_store), data.to_owned())?;
+        };
+
+        self.store = new_store as S;
+        Ok(Instance { store: new_store, subs: self.subs, peers: self.peers, id_pool: self.id_pool })
+    }
 }
 
 impl<S: Store> fmt::Debug for Instance<S> {

src/core/instance/store.rs

@@ -1,6 +1,12 @@
+
+use std::iter::Map;
+use std::option::Iter;
+
 use crate::error::MizeResult;
 use crate::item::{Item, ItemData};
 use crate::id::MizeId;
+use crate::memstore::MemStore;
+use crate::instance::Instance;
 
 pub trait Store {
     // should have the ability to be multi threaded, if the underlying implementation supports 
@@ -23,5 +29,7 @@ pub trait Store {
     fn get_value_raw(&self, id: MizeId) -> MizeResult<Vec<u8>>;
 
     fn get_value_data_full(&self, id: MizeId) -> MizeResult<ItemData>;
+
+    fn id_iter(&self) -> MizeResult<impl Iterator<Item=String> + '_>;
 }
 

src/core/item.rs

@@ -41,6 +41,11 @@ impl<S: Store> Item<'_, S> {
         // this will call from the instance which gets the value from the store
         self.instance.store.get_value_raw(self.id())
     }
+    pub fn value_string(&self) -> MizeResult<String> {
+        let raw = self.value_raw()?;
+        String::from_utf8(raw.clone())
+            .mize_result_msg(format!("failed to convert raw value from item '{}' into a utf-8 string. raw value was: '{:02X?}'", self.id(), raw))
+    }
     pub fn as_data_full(&self) -> MizeResult<ItemData> {
         self.instance.store.get_value_data_full(self.id())
     }
@@ -73,6 +78,10 @@ impl ItemData {
         item_data_merge(&mut self.0, &other.0);
     }
 
+    pub fn cbor(&self) -> &CborValue {
+        &self.0
+    }
+
     pub fn null() -> CborValue {
         CborValue::Null
     }
@@ -106,7 +115,7 @@ impl ItemData {
 
 }
 
-fn item_data_get_path(data: &CborValue, path: Vec<String>) -> MizeResult<&CborValue> {
+pub fn item_data_get_path(data: &CborValue, path: Vec<String>) -> MizeResult<&CborValue> {
     let mut path_iter = path.clone().into_iter();
     let path_el = match path_iter.nth(0) {
         Some(val) => val,
@@ -133,7 +142,7 @@ fn item_data_get_path(data: &CborValue, path: Vec<String>) -> MizeResult<&CborVa
     item_data_get_path(sub_data, path_iter.collect())
 }
 
-fn item_data_set_path(data: &mut CborValue, path: Vec<String>, data_to_set: &CborValue) -> MizeResult<()> {
+pub fn item_data_set_path(data: &mut CborValue, path: Vec<String>, data_to_set: &CborValue) -> MizeResult<()> {
     //trace!("[ {} ] item_data_set_path()", "CALL".yellow());
     //trace!("[ {} ] data: {}", "ARG".yellow(), data.clone().into_item_data());
     //trace!("[ {} ] path: {:?}", "ARG".yellow(), path);
@@ -177,7 +186,7 @@ fn item_data_set_path(data: &mut CborValue, path: Vec<String>, data_to_set: &Cbo
     return Err(MizeError::new().msg("unreachable"));
 }
 
-fn item_data_merge(merge_into: &mut CborValue, other: &CborValue){
+pub fn item_data_merge(merge_into: &mut CborValue, other: &CborValue){
     // needs to be recursive
 
     match (merge_into, other) {

src/core/memstore.rs

@@ -10,6 +10,7 @@ use crate::id::MizeId;
 use crate::instance::store::Store;
 use crate::error::{MizeError, MizeResult, IntoMizeResult};
 use crate::item::{Item, ItemData};
+use crate::instance::Instance;
 
 #[derive(Clone, Debug)]
 pub struct MemStore {
@@ -79,6 +80,12 @@ impl Store for MemStore {
 
         return Ok(ret_data);
     }
+    fn id_iter(&self) -> MizeResult<impl Iterator<Item=String> + '_> {
+        let inner = self.inner.lock()?;
+
+        let keys: Vec<String> = inner.map.keys().map(|v| format!("{}", v)).collect();
+        return Ok(keys.into_iter());
+    }
 }
 
 impl MemStore {
@@ -94,7 +101,7 @@ fn id_to_u64(id: MizeId) -> MizeResult<u64> {
         .mize_result_msg(format!("Could not parse the store_part of mizeid {} into a u64 for the MemStore", id))
 }
 
-fn get_raw_from_cbor<'a>(value: &'a CborValue, path: Vec<&String>) -> MizeResult<&'a [u8]> {
+pub fn get_raw_from_cbor<'a>(value: &'a CborValue, path: Vec<&String>) -> MizeResult<&'a [u8]> {
     trace!("[ {} ] get_raw_from_cbor()", "CALL".yellow());
     trace!("[ {} ] value: {:?}", "ARG".yellow(), value);
     trace!("[ {} ] path: {:?}", "ARG".yellow(), path);