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