dirty

Author: uint

docs-test-gen/templates/storey-container-impl.tpl

@@ -7,8 +7,8 @@
 )]
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::*;
-use storey::containers::{NonTerminal, Storable};
-use storey::storage::StorageBranch;
+use storey::containers::{IterableStorable, NonTerminal, Storable};
+use storey::storage::{IntoStorage, StorageBranch};
 
 mod users {
     use super::*;
@@ -75,7 +75,6 @@ struct MyMap<V> {
 impl<V> MyMap<V>
 where
     V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
 {
     pub const fn new(prefix: u8) -> Self {
         Self {
@@ -84,7 +83,11 @@ where
         }
     }
 
-    pub fn access<S>(&self, storage: S) -> MyMapAccess<V, StorageBranch<S>> {
+    pub fn access<F, S>(&self, storage: F) -> MyMapAccess<V, StorageBranch<S>>
+    where
+        (F,): IntoStorage<S>,
+    {
+        let storage = (storage,).into_storage();
         Self::access_impl(StorageBranch::new(storage, vec![self.prefix]))
     }
 }
@@ -97,21 +100,27 @@ pub struct MyMapAccess<V, S> {
 impl<V> Storable for MyMap<V>
 where
     V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
 {
     type Kind = NonTerminal;
     type Accessor<S> = MyMapAccess<V, S>;
-    type Key = (u32, V::Key);
-    type KeyDecodeError = ();
-    type Value = V::Value;
-    type ValueDecodeError = V::ValueDecodeError;
 
     fn access_impl<S>(storage: S) -> MyMapAccess<V, S> {
         MyMapAccess {
             storage,
             phantom: std::marker::PhantomData,
         }
     }
+}
+
+impl<V> IterableStorable for MyMap<V>
+where
+    V: IterableStorable,
+    <V as IterableStorable>::KeyDecodeError: std::fmt::Display,
+{
+    type Key = (u32, V::Key);
+    type KeyDecodeError = ();
+    type Value = V::Value;
+    type ValueDecodeError = V::ValueDecodeError;
 
     fn decode_key(key: &[u8]) -> Result<Self::Key, ()> {
         todo!()

src/pages/storey/container-impl.mdx

@@ -49,8 +49,9 @@ The constructor is simple - it just initializes the fields.
 
 The next step is to set up an accessor. Hold on tight! This will be a ride.
 
-```rust template="storage" {1, 9-11, 20-22, 25-56}
-use storey::containers::{NonTerminal, Storable};
+```rust template="storage" {1-2, 10-11, 20-26, 29-66}
+use storey::containers::{IterableStorable, NonTerminal, Storable};
+use storey::storage::{IntoStorage, StorageBranch};
 
 struct MyMap<V> {
     prefix: u8,
@@ -60,7 +61,6 @@ struct MyMap<V> {
 impl<V> MyMap<V>
 where
     V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
 {
     pub const fn new(prefix: u8) -> Self {
         Self {
@@ -69,7 +69,11 @@ where
         }
     }
 
-    pub fn access<S>(&self, storage: S) -> MyMapAccess<V, StorageBranch<S>> {
+    pub fn access<F, S>(&self, storage: F) -> MyMapAccess<V, StorageBranch<S>>
+    where
+        (F,): IntoStorage<S>,
+    {
+        let storage = (storage,).into_storage();
         Self::access_impl(StorageBranch::new(storage, vec![self.prefix]))
     }
 }
@@ -82,21 +86,27 @@ pub struct MyMapAccess<V, S> {
 impl<V> Storable for MyMap<V>
 where
     V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
 {
     type Kind = NonTerminal;
     type Accessor<S> = MyMapAccess<V, S>;
-    type Key = (u32, V::Key);
-    type KeyDecodeError = ();
-    type Value = V::Value;
-    type ValueDecodeError = V::ValueDecodeError;
 
     fn access_impl<S>(storage: S) -> MyMapAccess<V, S> {
         MyMapAccess {
             storage,
             phantom: std::marker::PhantomData,
         }
     }
+}
+
+impl<V> IterableStorable for MyMap<V>
+where
+    V: IterableStorable,
+    <V as IterableStorable>::KeyDecodeError: std::fmt::Display,
+{
+    type Key = (u32, V::Key);
+    type KeyDecodeError = ();
+    type Value = V::Value;
+    type ValueDecodeError = V::ValueDecodeError;
 
     fn decode_key(key: &[u8]) -> Result<Self::Key, ()> {
         todo!()
@@ -114,6 +124,8 @@ The `MyMapAccess` struct is our accessor. It's a facade that's used to actually
 the collection given a `Storage` instance - this is usually a subspace of the "root" storage
 backend.
 
+TODO: rework this
+
 The [`Storable`] trait is the main trait a container must implement. It's currently a mix of things.
 The associated types tell the framework: | Associated type | Details |
 |-------------------|-------------------------------------------------------------------------| |
@@ -138,8 +150,8 @@ container.
 There's one thing we're missing for this to actually by useful. We need some methods for the
 accessor.
 
-```rust template="storage" {2, 59-78}
-use storey::containers::{NonTerminal, Storable};
+```rust template="storage" {68-83}
+use storey::containers::{IterableStorable, NonTerminal, Storable};
 use storey::storage::StorageBranch;
 
 struct MyMap<V> {
@@ -150,7 +162,6 @@ struct MyMap<V> {
 impl<V> MyMap<V>
 where
     V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
 {
     pub const fn new(prefix: u8) -> Self {
         Self {
@@ -159,7 +170,11 @@ where
         }
     }
 
-    pub fn access<S>(&self, storage: S) -> MyMapAccess<V, StorageBranch<S>> {
+    pub fn access<F, S>(&self, storage: F) -> MyMapAccess<V, StorageBranch<S>>
+    where
+        (F,): IntoStorage<S>,
+    {
+        let storage = (storage,).into_storage();
         Self::access_impl(StorageBranch::new(storage, vec![self.prefix]))
     }
 }
@@ -172,21 +187,27 @@ pub struct MyMapAccess<V, S> {
 impl<V> Storable for MyMap<V>
 where
     V: Storable,
-    <V as Storable>::KeyDecodeError: std::fmt::Display,
 {
     type Kind = NonTerminal;
     type Accessor<S> = MyMapAccess<V, S>;
-    type Key = (u32, V::Key);
-    type KeyDecodeError = ();
-    type Value = V::Value;
-    type ValueDecodeError = V::ValueDecodeError;
 
     fn access_impl<S>(storage: S) -> MyMapAccess<V, S> {
         MyMapAccess {
             storage,
             phantom: std::marker::PhantomData,
         }
     }
+}
+
+impl<V> IterableStorable for MyMap<V>
+where
+    V: IterableStorable,
+    <V as IterableStorable>::KeyDecodeError: std::fmt::Display,
+{
+    type Key = (u32, V::Key);
+    type KeyDecodeError = ();
+    type Value = V::Value;
+    type ValueDecodeError = V::ValueDecodeError;
 
     fn decode_key(key: &[u8]) -> Result<Self::Key, ()> {
         todo!()
@@ -223,15 +244,13 @@ Time to see this in action.
 
 ```rust template="storey-container-impl"
 use cw_storey::containers::{Item};
-use cw_storey::CwStorage;
 
 use storey::containers::IterableAccessor as _;
 
 const MAP_IX: u8 = 0;
 
 let my_map: MyMap<Item<u32>> = MyMap::new(MAP_IX);
-let mut cw_storage = CwStorage(&mut storage);
-let mut access = my_map.access(&mut cw_storage);
+let mut access = my_map.access(&mut storage);
 
 access.entry_mut(1).set(&100).unwrap();
 access.entry_mut(2).set(&200).unwrap();