1use near_sdk::{
2 borsh::{BorshDeserialize, BorshSerialize},
3 store::{
4 iterable_map::{self, IterableMap},
5 key::ToKey,
6 lookup_map::{self, LookupMap},
7 },
8};
9
10use super::{Entry, Map, OccupiedEntry, VacantEntry};
11
12impl<K, V, H> Map for LookupMap<K, V, H>
13where
14 K: Ord + BorshSerialize + Clone,
15 V: BorshSerialize + BorshDeserialize,
16 H: ToKey,
17{
18 type K = K;
19
20 type V = V;
21
22 type VacantEntry<'a>
23 = lookup_map::VacantEntry<'a, K, V>
24 where
25 Self: 'a;
26
27 type OccupiedEntry<'a>
28 = lookup_map::OccupiedEntry<'a, K, V>
29 where
30 Self: 'a;
31
32 #[inline]
33 fn contains_key(&self, k: &Self::K) -> bool {
34 self.contains_key(k)
35 }
36
37 #[inline]
38 fn get(&self, k: &Self::K) -> Option<&Self::V> {
39 self.get(k)
40 }
41
42 #[inline]
43 fn get_mut(&mut self, k: &Self::K) -> Option<&mut Self::V> {
44 self.get_mut(k)
45 }
46
47 #[inline]
48 fn insert(&mut self, k: Self::K, v: Self::V) -> Option<Self::V> {
49 self.insert(k, v)
50 }
51
52 #[inline]
53 fn entry(&mut self, k: Self::K) -> Entry<Self::VacantEntry<'_>, Self::OccupiedEntry<'_>> {
54 match self.entry(k) {
55 lookup_map::Entry::Occupied(entry) => Entry::Occupied(entry),
56 lookup_map::Entry::Vacant(entry) => Entry::Vacant(entry),
57 }
58 }
59
60 #[inline]
61 fn remove(&mut self, k: &Self::K) -> Option<Self::V> {
62 self.remove(k)
63 }
64}
65
66impl<'a, K, V> VacantEntry<'a> for lookup_map::VacantEntry<'a, K, V> {
67 type K = K;
68
69 type V = V;
70
71 #[inline]
72 fn key(&self) -> &Self::K {
73 self.key()
74 }
75
76 #[inline]
77 fn into_key(self) -> Self::K {
78 self.into_key()
79 }
80
81 #[inline]
82 fn insert(self, v: Self::V) -> &'a mut Self::V {
83 self.insert(v)
84 }
85}
86
87impl<'a, K, V> OccupiedEntry<'a> for lookup_map::OccupiedEntry<'a, K, V> {
88 type K = K;
89
90 type V = V;
91
92 #[inline]
93 fn key(&self) -> &Self::K {
94 self.key()
95 }
96
97 #[inline]
98 fn get(&self) -> &Self::V {
99 self.get()
100 }
101
102 #[inline]
103 fn get_mut(&mut self) -> &mut Self::V {
104 self.get_mut()
105 }
106
107 #[inline]
108 fn into_mut(self) -> &'a mut Self::V {
109 self.into_mut()
110 }
111
112 #[inline]
113 fn insert(&mut self, v: Self::V) -> Self::V {
114 self.insert(v)
115 }
116
117 #[inline]
118 fn remove(self) -> Self::V {
119 self.remove()
120 }
121}
122
123impl<K, V, H> Map for IterableMap<K, V, H>
124where
125 K: Ord + BorshSerialize + BorshDeserialize + Clone,
126 V: BorshSerialize + BorshDeserialize,
127 H: ToKey,
128{
129 type K = K;
130
131 type V = V;
132
133 type VacantEntry<'a>
134 = iterable_map::VacantEntry<'a, K, V, H>
135 where
136 Self: 'a;
137
138 type OccupiedEntry<'a>
139 = iterable_map::OccupiedEntry<'a, K, V, H>
140 where
141 Self: 'a;
142
143 #[inline]
144 fn contains_key(&self, k: &Self::K) -> bool {
145 self.contains_key(k)
146 }
147
148 #[inline]
149 fn get(&self, k: &Self::K) -> Option<&Self::V> {
150 self.get(k)
151 }
152
153 #[inline]
154 fn get_mut(&mut self, k: &Self::K) -> Option<&mut Self::V> {
155 self.get_mut(k)
156 }
157
158 #[inline]
159 fn insert(&mut self, k: Self::K, v: Self::V) -> Option<Self::V> {
160 self.insert(k, v)
161 }
162
163 #[inline]
164 fn entry(&mut self, k: Self::K) -> Entry<Self::VacantEntry<'_>, Self::OccupiedEntry<'_>> {
165 match self.entry(k) {
166 iterable_map::Entry::Occupied(entry) => Entry::Occupied(entry),
167 iterable_map::Entry::Vacant(entry) => Entry::Vacant(entry),
168 }
169 }
170
171 #[inline]
172 fn remove(&mut self, k: &Self::K) -> Option<Self::V> {
173 self.remove(k)
174 }
175}
176
177impl<'a, K, V, H> VacantEntry<'a> for iterable_map::VacantEntry<'a, K, V, H>
178where
179 K: Ord + BorshSerialize + BorshDeserialize + Clone,
180 V: BorshSerialize + BorshDeserialize,
181 H: ToKey,
182{
183 type K = K;
184
185 type V = V;
186
187 #[inline]
188 fn key(&self) -> &Self::K {
189 self.key()
190 }
191
192 #[inline]
193 fn into_key(self) -> Self::K {
194 self.into_key()
195 }
196
197 #[inline]
198 fn insert(self, v: Self::V) -> &'a mut Self::V {
199 self.insert(v)
200 }
201}
202
203impl<'a, K, V, H> OccupiedEntry<'a> for iterable_map::OccupiedEntry<'a, K, V, H>
204where
205 K: Ord + BorshSerialize + BorshDeserialize + Clone,
206 V: BorshSerialize + BorshDeserialize,
207 H: ToKey,
208{
209 type K = K;
210
211 type V = V;
212
213 #[inline]
214 fn key(&self) -> &Self::K {
215 self.key()
216 }
217
218 #[inline]
219 fn get(&self) -> &Self::V {
220 self.get()
221 }
222
223 #[inline]
224 fn get_mut(&mut self) -> &mut Self::V {
225 self.get_mut()
226 }
227
228 #[inline]
229 fn into_mut(self) -> &'a mut Self::V {
230 self.into_mut()
231 }
232
233 #[inline]
234 fn insert(&mut self, v: Self::V) -> Self::V {
235 self.insert(v)
236 }
237
238 #[inline]
239 fn remove(self) -> Self::V {
240 self.remove()
241 }
242}
243
244impl<K, V, H> crate::IterableMap for IterableMap<K, V, H>
245where
246 K: Ord + BorshSerialize + BorshDeserialize + Clone,
247 V: BorshSerialize + BorshDeserialize,
248 H: ToKey,
249{
250 type Keys<'a>
251 = iterable_map::Keys<'a, K>
252 where
253 Self: 'a;
254
255 type Values<'a>
256 = iterable_map::Values<'a, K, V, H>
257 where
258 Self: 'a;
259
260 type ValuesMut<'a>
261 = iterable_map::ValuesMut<'a, K, V, H>
262 where
263 Self: 'a;
264
265 type Iter<'a>
266 = iterable_map::Iter<'a, K, V, H>
267 where
268 Self: 'a;
269
270 type IterMut<'a>
271 = iterable_map::IterMut<'a, K, V, H>
272 where
273 Self: 'a;
274
275 type Drain<'a>
276 = iterable_map::Drain<'a, K, V, H>
277 where
278 Self: 'a;
279
280 #[inline]
281 fn len(&self) -> usize {
282 self.len().try_into().unwrap_or_else(|_| unreachable!())
283 }
284
285 #[inline]
286 fn is_empty(&self) -> bool {
287 self.is_empty()
288 }
289
290 #[inline]
291 fn keys(&self) -> Self::Keys<'_> {
292 self.keys()
293 }
294
295 #[inline]
296 fn values(&self) -> Self::Values<'_> {
297 self.values()
298 }
299
300 #[inline]
301 fn values_mut(&mut self) -> Self::ValuesMut<'_> {
302 self.values_mut()
303 }
304
305 #[inline]
306 fn iter(&self) -> Self::Iter<'_> {
307 self.iter()
308 }
309
310 #[inline]
311 fn iter_mut(&mut self) -> Self::IterMut<'_> {
312 self.iter_mut()
313 }
314
315 #[inline]
316 fn drain(&mut self) -> Self::Drain<'_> {
317 self.drain()
318 }
319
320 #[inline]
321 fn clear(&mut self) {
322 self.clear();
323 }
324}