# durableMap

durableMap is in-memory, durable storage
optimized for ( write-heavy, read-heavy )


# Why need to DurableMap ??

it is a concurrent hashMap using NonBlocking wal engine for persist to disk 
it avoid any loss data



# Example

 ```rust
 
 #[tokio::main]
 async fn main() {
 
     
    // Optimized for write concurrent (API is same) 
    let dlw = WConcurrentStorage::<Document>::open("tester".to_owned(), 1000).await;
    
    // Optimized for read concurrent
    let dlr = RConcurrentStorage::<Document>::open("tester".to_owned(), 1000).await;
 
    
    // Insert / Update
    let _ = dlr.insert_entry(format!("102xa"), Document::new()).await;

    let _ = dlw.insert_entry(format!("102xa"), Document::new()).await;

    
    // Remove
    dlr.remove_entry(&format("102xa")).await;

    dlw.remove_entry(&format("102xa")).await;

    // Read
    dlr.table.read().await
            .iter()
            .for_each(|(key, doc)| {
                println!("==> {} -> {}", key, &doc.funame)
            });


    // Just Difference (RConcurrentStorage) and (WConcurrentStorage) is
    //  WConcurrentStorage for iter  table dont need lock
    //      because internally used sharded lock

    dlw.table
            .iter()
            .for_each(|(key, doc)| {
                println!("==> {} -> {}", key, &doc.funame)
            });
 }  
 
 
 #[derive(Serialize, Deserialize, Clone)]
 struct Document {
     funame: String,
     age: i32,
 }
 impl Document {
     pub fn new() -> Self {
         Document { 
             funame: String::from("DanyalMh"), 
             age: 24, 
         }
     }
 }
 
 
 
``` 
 

# Installation

``` 
[dependencies]

rstorage = "1.0.2"

```