fuel_core/state/
generic_database.rs

1use fuel_core_storage::{
2    Error as StorageError,
3    Mappable,
4    MerkleRoot,
5    MerkleRootStorage,
6    PredicateStorageRequirements,
7    Result as StorageResult,
8    StorageAsRef,
9    StorageInspect,
10    StorageRead,
11    StorageSize,
12    iter::{
13        BoxedIter,
14        IterDirection,
15        IterableStore,
16    },
17    kv_store::{
18        KVItem,
19        KeyValueInspect,
20        Value,
21    },
22    structured_storage::StructuredStorage,
23    tables::BlobData,
24};
25use std::{
26    borrow::Cow,
27    fmt::Debug,
28};
29
30#[derive(Debug, Clone)]
31pub struct GenericDatabase<Storage, Metadata> {
32    storage: StructuredStorage<Storage>,
33    metadata: Option<Metadata>,
34}
35
36impl<Storage, Metadata> GenericDatabase<Storage, Metadata> {
37    pub fn inner_storage(&self) -> &Storage {
38        self.storage.as_ref()
39    }
40
41    pub fn metadata(&self) -> Option<&Metadata> {
42        self.metadata.as_ref()
43    }
44
45    pub fn from_storage_and_metadata(
46        storage: Storage,
47        metadata: Option<Metadata>,
48    ) -> Self {
49        Self {
50            storage: StructuredStorage::new(storage),
51            metadata,
52        }
53    }
54
55    pub fn into_inner(self) -> (Storage, Option<Metadata>) {
56        (self.storage.into_storage(), self.metadata)
57    }
58}
59
60impl<M, Storage, Metadata> StorageInspect<M> for GenericDatabase<Storage, Metadata>
61where
62    M: Mappable,
63    StructuredStorage<Storage>: StorageInspect<M, Error = StorageError>,
64{
65    type Error = StorageError;
66
67    fn get(&self, key: &M::Key) -> Result<Option<Cow<'_, M::OwnedValue>>, Self::Error> {
68        self.storage.storage::<M>().get(key)
69    }
70
71    fn contains_key(&self, key: &M::Key) -> Result<bool, Self::Error> {
72        self.storage.storage::<M>().contains_key(key)
73    }
74}
75
76impl<M, Storage, Metadata> StorageSize<M> for GenericDatabase<Storage, Metadata>
77where
78    M: Mappable,
79    StructuredStorage<Storage>: StorageSize<M, Error = StorageError>,
80{
81    fn size_of_value(&self, key: &M::Key) -> Result<Option<usize>, Self::Error> {
82        <_ as StorageSize<M>>::size_of_value(&self.storage, key)
83    }
84}
85
86impl<M, Storage, Metadata> StorageRead<M> for GenericDatabase<Storage, Metadata>
87where
88    M: Mappable,
89    StructuredStorage<Storage>: StorageRead<M, Error = StorageError>,
90{
91    fn read(
92        &self,
93        key: &M::Key,
94        offset: usize,
95        buf: &mut [u8],
96    ) -> Result<bool, Self::Error> {
97        self.storage.storage::<M>().read(key, offset, buf)
98    }
99
100    fn read_alloc(&self, key: &M::Key) -> Result<Option<Vec<u8>>, Self::Error> {
101        self.storage.storage::<M>().read_alloc(key)
102    }
103}
104
105impl<Key, M, Storage, Metadata> MerkleRootStorage<Key, M>
106    for GenericDatabase<Storage, Metadata>
107where
108    M: Mappable,
109    StructuredStorage<Storage>: MerkleRootStorage<Key, M, Error = StorageError>,
110{
111    fn root(&self, key: &Key) -> Result<MerkleRoot, Self::Error> {
112        self.storage.storage::<M>().root(key)
113    }
114}
115
116impl<Storage, Metadata> KeyValueInspect for GenericDatabase<Storage, Metadata>
117where
118    Storage: KeyValueInspect,
119{
120    type Column = Storage::Column;
121
122    fn exists(&self, key: &[u8], column: Self::Column) -> StorageResult<bool> {
123        self.storage.exists(key, column)
124    }
125
126    fn size_of_value(
127        &self,
128        key: &[u8],
129        column: Self::Column,
130    ) -> StorageResult<Option<usize>> {
131        KeyValueInspect::size_of_value(&self.storage, key, column)
132    }
133
134    fn get(&self, key: &[u8], column: Self::Column) -> StorageResult<Option<Value>> {
135        KeyValueInspect::get(&self.storage, key, column)
136    }
137
138    fn read(
139        &self,
140        key: &[u8],
141        column: Self::Column,
142        offset: usize,
143        buf: &mut [u8],
144    ) -> StorageResult<bool> {
145        KeyValueInspect::read(&self.storage, key, column, offset, buf)
146    }
147}
148
149impl<Storage, Metadata> IterableStore for GenericDatabase<Storage, Metadata>
150where
151    Storage: IterableStore,
152{
153    fn iter_store(
154        &self,
155        column: Self::Column,
156        prefix: Option<&[u8]>,
157        start: Option<&[u8]>,
158        direction: IterDirection,
159    ) -> BoxedIter<'_, KVItem> {
160        self.storage.iter_store(column, prefix, start, direction)
161    }
162
163    fn iter_store_keys(
164        &self,
165        column: Self::Column,
166        prefix: Option<&[u8]>,
167        start: Option<&[u8]>,
168        direction: IterDirection,
169    ) -> BoxedIter<'_, fuel_core_storage::kv_store::KeyItem> {
170        self.storage
171            .iter_store_keys(column, prefix, start, direction)
172    }
173}
174
175impl<Storage, Metadata> AsRef<Storage> for GenericDatabase<Storage, Metadata> {
176    fn as_ref(&self) -> &Storage {
177        self.storage.as_ref()
178    }
179}
180
181impl<Storage, Metadata> AsMut<Storage> for GenericDatabase<Storage, Metadata> {
182    fn as_mut(&mut self) -> &mut Storage {
183        self.storage.as_mut()
184    }
185}
186
187impl<Storage, Metadata> core::ops::Deref for GenericDatabase<Storage, Metadata> {
188    type Target = Storage;
189
190    fn deref(&self) -> &Self::Target {
191        self.as_ref()
192    }
193}
194
195impl<Storage, Metadata> core::ops::DerefMut for GenericDatabase<Storage, Metadata> {
196    fn deref_mut(&mut self) -> &mut Self::Target {
197        self.as_mut()
198    }
199}
200
201impl<Storage, Error, Metadata> PredicateStorageRequirements
202    for GenericDatabase<Storage, Metadata>
203where
204    Self: StorageRead<BlobData, Error = Error>,
205    Error: Debug,
206{
207    fn storage_error_to_string(error: Error) -> String {
208        format!("{:?}", error)
209    }
210}
fuel_core/state/generic_database.rs

fuel_core/state/
generic_database.rs
