ink_storage_traits/impls/
mod.rs

1// Copyright (C) Use Ink (UK) Ltd.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use crate::{
16    AutoStorableHint,
17    Packed,
18    StorableHint,
19    StorageKey,
20};
21use core::{
22    fmt::Debug,
23    marker::PhantomData,
24};
25use ink_primitives::{
26    Key,
27    KeyComposer,
28};
29
30/// The private trait helping identify the [`AutoKey`] key type.
31trait KeyType {
32    /// It is `true` for [`AutoKey`] and `false` for [`ManualKey`].
33    /// It helps the [`ResolverKey`] select between the user-specified (left key)
34    /// and the auto-generated (right key) keys.
35    const IS_AUTO_KEY: bool;
36}
37
38/// Auto key type means that the storage key should be calculated automatically.
39#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd)]
40#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
41pub struct AutoKey;
42
43impl StorageKey for AutoKey {
44    const KEY: Key = 0;
45}
46
47impl KeyType for AutoKey {
48    const IS_AUTO_KEY: bool = true;
49}
50
51impl Debug for AutoKey {
52    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
53        f.debug_struct("AutoKey")
54            .field("key", &<Self as StorageKey>::KEY)
55            .finish()
56    }
57}
58
59/// Manual key type specifies the storage key.
60#[derive(Default, Copy, Clone, Eq, PartialEq, PartialOrd)]
61#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
62pub struct ManualKey<const KEY: Key, ParentKey: StorageKey = ()>(
63    PhantomData<fn() -> ParentKey>,
64);
65
66impl<const KEY: Key, ParentKey: StorageKey> StorageKey for ManualKey<KEY, ParentKey> {
67    const KEY: Key = KeyComposer::concat(KEY, ParentKey::KEY);
68}
69
70impl<const KEY: Key, ParentKey: StorageKey> KeyType for ManualKey<KEY, ParentKey> {
71    const IS_AUTO_KEY: bool = false;
72}
73
74impl<const KEY: Key, ParentKey: StorageKey> Debug for ManualKey<KEY, ParentKey> {
75    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
76        f.debug_struct("ManualKey")
77            .field("key", &<Self as StorageKey>::KEY)
78            .finish()
79    }
80}
81
82/// Resolver key type selects between preferred key and autogenerated key.
83/// If the `L` type is `AutoKey` it returns auto-generated `R` else `L`.
84#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
85#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
86pub struct ResolverKey<L, R>(PhantomData<fn() -> (L, R)>);
87
88impl<L, R> StorageKey for ResolverKey<L, R>
89where
90    L: StorageKey + KeyType,
91    R: StorageKey + KeyType,
92{
93    /// If the left key is [`AutoKey`], then use the right auto-generated storage key.
94    /// Otherwise use the left [`ManualKey`].
95    const KEY: Key = if L::IS_AUTO_KEY { R::KEY } else { L::KEY };
96}
97
98impl<L, R> KeyType for ResolverKey<L, R>
99where
100    L: KeyType,
101    R: KeyType,
102{
103    /// The right key is always an auto-generated key, the user can specify only the left
104    /// key. So the left key defines the [`KeyType::IS_AUTO_KEY`] of the
105    /// [`ResolverKey`].
106    const IS_AUTO_KEY: bool = L::IS_AUTO_KEY;
107}
108
109type FinalKey<T, const KEY: Key, ParentKey> =
110    ResolverKey<<T as StorableHint<ParentKey>>::PreferredKey, ManualKey<KEY, ParentKey>>;
111
112// `AutoStorableHint` trait figures out that storage key it should use.
113// - If the `PreferredKey` is `AutoKey` it will use an auto-generated key passed as
114//   generic
115// into `AutoStorableHint`.
116// - If `PreferredKey` is `ManualKey`, then it will use it.
117impl<T, const KEY: Key, ParentKey> AutoStorableHint<ManualKey<KEY, ParentKey>> for T
118where
119    T: StorableHint<ParentKey>,
120    <T as StorableHint<ParentKey>>::PreferredKey: KeyType,
121    T: StorableHint<FinalKey<T, KEY, ParentKey>>,
122    ParentKey: StorageKey,
123{
124    type Type = <T as StorableHint<FinalKey<T, KEY, ParentKey>>>::Type;
125}
126
127impl<P> super::storage::private::Sealed for P where P: scale::Decode + scale::Encode {}
128impl<P> Packed for P where P: scale::Decode + scale::Encode {}
129
130impl<P> StorageKey for P
131where
132    P: Packed,
133{
134    const KEY: Key = 0;
135}
136
137impl<P, Key> StorableHint<Key> for P
138where
139    P: Packed,
140    Key: StorageKey,
141{
142    type Type = P;
143    type PreferredKey = AutoKey;
144}
145
146#[cfg(test)]
147mod tests {
148    use super::*;
149
150    /// Creates test to verify that the primitive types are packed.
151    #[macro_export]
152    macro_rules! storage_hint_works_for_primitive {
153        ( $ty:ty ) => {
154            paste::item! {
155                #[test]
156                #[allow(non_snake_case)]
157                fn [<$ty _storage_hint_works>] () {
158                    assert_eq!(
159                        ::core::any::TypeId::of::<$ty>(),
160                        ::core::any::TypeId::of::<<$ty as $crate::StorableHint<$crate::ManualKey<123>>>::Type>()
161                    );
162                }
163            }
164        };
165    }
166    mod arrays {
167        use crate::storage_hint_works_for_primitive;
168
169        type Array = [i32; 4];
170        storage_hint_works_for_primitive!(Array);
171
172        type ArrayTuples = [(i32, i32); 2];
173        storage_hint_works_for_primitive!(ArrayTuples);
174    }
175
176    mod prims {
177        use crate::storage_hint_works_for_primitive;
178        use ink_primitives::AccountId;
179
180        storage_hint_works_for_primitive!(bool);
181        storage_hint_works_for_primitive!(String);
182        storage_hint_works_for_primitive!(AccountId);
183        storage_hint_works_for_primitive!(i8);
184        storage_hint_works_for_primitive!(i16);
185        storage_hint_works_for_primitive!(i32);
186        storage_hint_works_for_primitive!(i64);
187        storage_hint_works_for_primitive!(i128);
188        storage_hint_works_for_primitive!(u8);
189        storage_hint_works_for_primitive!(u16);
190        storage_hint_works_for_primitive!(u32);
191        storage_hint_works_for_primitive!(u64);
192        storage_hint_works_for_primitive!(u128);
193
194        type OptionU8 = Option<u8>;
195        storage_hint_works_for_primitive!(OptionU8);
196
197        type ResultU8 = Result<u8, bool>;
198        storage_hint_works_for_primitive!(ResultU8);
199
200        type BoxU8 = Box<u8>;
201        storage_hint_works_for_primitive!(BoxU8);
202
203        type BoxOptionU8 = Box<Option<u8>>;
204        storage_hint_works_for_primitive!(BoxOptionU8);
205    }
206
207    mod tuples {
208        use crate::storage_hint_works_for_primitive;
209
210        type TupleSix = (i32, u32, String, u8, bool, Box<Option<i32>>);
211        storage_hint_works_for_primitive!(TupleSix);
212    }
213
214    #[test]
215    fn storage_key_types_works() {
216        assert_eq!(<AutoKey as StorageKey>::KEY, 0);
217        assert_eq!(<ManualKey<123> as StorageKey>::KEY, 123);
218        assert_eq!(<ManualKey<0> as StorageKey>::KEY, 0);
219        assert_eq!(<ResolverKey<AutoKey, AutoKey> as StorageKey>::KEY, 0);
220        assert_eq!(
221            <ResolverKey<AutoKey, ManualKey<123>> as StorageKey>::KEY,
222            123
223        );
224        assert_eq!(
225            <ResolverKey<ManualKey<456>, ManualKey<123>> as StorageKey>::KEY,
226            456
227        );
228        assert_eq!(
229            <ResolverKey<ManualKey<0>, ManualKey<123>> as StorageKey>::KEY,
230            0
231        );
232    }
233}
ink_storage_traits/impls/mod.rs

ink_storage_traits/impls/
mod.rs
