v2 api storage

1 files changed, 28 insertions, 46 deletions

diff --git a/src/storage/mod.rs b/src/storage/mod.rs
index 6b410a2..4ef2d61 100644
--- a/src/storage/mod.rs
+++ b/src/storage/mod.rs
@@ -1,19 +1,14 @@
 /*
- * T1 : Filter
- * T2 : Range
- * T3 : Atom
- */
-
-/*
- * My idea: we can encapsulate the causality token
- * into the object system so it is not exposed.
  *
  * This abstraction goal is to leverage all the semantic of Garage K2V+S3,
  * to be as tailored as possible to it ; it aims to be a zero-cost abstraction
  * compared to when we where directly using the K2V+S3 client.
+ *
+ * My idea: we can encapsulate the causality token
+ * into the object system so it is not exposed.
  */
 
-
+mod in_memory;
 mod garage;
 
 pub enum Selector<'a> {
@@ -27,55 +22,42 @@ pub enum Alternative {
 }
 type ConcurrentValues = Vec<Alternative>;
 
+#[derive(Debug)]
 pub enum Error {
     NotFound,
     Internal,
 }
 
-// ------ Store
-pub trait RowStore {
-    fn new_row(&self, partition: &str, sort: &str) -> impl RowRef;
-    fn new_row_batch(&self, partition: &str, filter: Selector) -> impl RowRefBatch;
-    fn new_blob(&self, key: &str) -> impl BlobRef;
-    fn new_blob_list(&self) -> Vec<impl BlobRef>; 
+pub trait RowRealization: Sized {
+    type Store: RowStore<Self>;
+    type Ref: RowRef<Self>;
+    type Value: RowValue<Self>;
 }
 
-// ------- Row
-pub trait RowRef {
-    fn to_value(&self, content: &[u8]) -> impl RowValue;
-    async fn get(&self) -> Result<impl RowValue, Error>;
-    async fn rm(&self) -> Result<(), Error>;
-    async fn poll(&self) -> Result<Option<impl RowValue>, Error>;
+// ------ Row Builder
+pub trait RowBuilder<R: RowRealization> 
+{
+    fn row_store(&self) -> R::Store;
 }
 
-pub trait RowValue {
-    fn row_ref(&self) -> impl RowRef;
-    fn content(&self) -> ConcurrentValues;
-    async fn persist(&self) -> Result<(), Error>;
+// ------ Row Store
+pub trait RowStore<R: RowRealization> 
+{
+    fn new_row(&self, partition: &str, sort: &str) -> R::Ref;
 }
 
-// ------ Row batch
-pub trait RowRefBatch {
-    fn to_values(&self, content: Vec<&[u8]>) -> impl RowValueBatch;
-    fn into_independant(&self) -> Vec<impl RowRef>;
-    async fn get(&self) -> Result<impl RowValueBatch, Error>;
+// ------- Row Item
+pub trait RowRef<R: RowRealization> 
+{
+    fn set_value(&self, content: Vec<u8>) -> R::Value;
+    async fn fetch(&self) -> Result<R::Value, Error>;
     async fn rm(&self) -> Result<(), Error>;
+    async fn poll(&self) -> Result<Option<R::Value>, Error>;
 }
 
-pub trait RowValueBatch {
-    fn into_independant(&self) -> Vec<impl RowValue>;
-    fn content(&self) -> Vec<ConcurrentValues>;
-    async fn persist(&self) -> Result<(), Error>;
-}
-
-// ----- Blobs
-pub trait BlobRef {
-    fn set_value(&self, content: &[u8]) -> impl BlobValue;
-    async fn get(&self) -> impl BlobValue;
-    async fn copy(&self, dst: &impl BlobRef) -> ();
-    async fn rm(&self, key: &str) -> ();
-}
-
-pub trait BlobValue {
-    async fn persist();
+pub trait RowValue<R: RowRealization> 
+{
+    fn to_ref(&self) -> R::Ref;
+    fn content(&self) -> ConcurrentValues;
+    async fn push(&self) -> Result<(), Error>;
 }