multiversx_sc/storage/
storage_set.rs

1use unwrap_infallible::UnwrapInfallible;
2
3use crate::{
4    api::{
5        const_handles, use_raw_handle, ErrorApi, ManagedBufferApiImpl, ManagedTypeApi,
6        StorageReadApi, StorageReadApiImpl, StorageWriteApi, StorageWriteApiImpl,
7    },
8    codec::*,
9    contract_base::ExitCodecErrorHandler,
10    err_msg,
11    types::{BigInt, BigUint, ManagedBuffer, ManagedBufferBuilder, ManagedRef, ManagedType},
12};
13
14use super::StorageKey;
15
16struct StorageSetOutput<'k, A>
17where
18    A: StorageWriteApi + ManagedTypeApi + ErrorApi + 'static,
19{
20    key: ManagedRef<'k, A, StorageKey<A>>,
21}
22
23impl<'k, A> StorageSetOutput<'k, A>
24where
25    A: StorageWriteApi + ManagedTypeApi + ErrorApi + 'static,
26{
27    #[inline]
28    fn new(key: ManagedRef<'k, A, StorageKey<A>>) -> Self {
29        StorageSetOutput { key }
30    }
31
32    fn set_managed_buffer(&self, managed_buffer: &ManagedBuffer<A>) {
33        A::storage_write_api_impl().storage_store_managed_buffer_raw(
34            self.key.buffer.get_handle(),
35            managed_buffer.handle.clone(),
36        );
37    }
38}
39
40impl<A> TopEncodeOutput for StorageSetOutput<'_, A>
41where
42    A: StorageWriteApi + ManagedTypeApi + ErrorApi + 'static,
43{
44    type NestedBuffer = ManagedBufferBuilder<A>;
45
46    fn set_slice_u8(self, bytes: &[u8]) {
47        self.set_managed_buffer(&bytes.into())
48    }
49
50    #[inline]
51    fn supports_specialized_type<T: TryStaticCast>() -> bool {
52        T::type_eq::<ManagedBuffer<A>>() || T::type_eq::<BigUint<A>>() || T::type_eq::<BigInt<A>>()
53    }
54
55    #[inline]
56    fn set_specialized<T, H>(self, value: &T, h: H) -> Result<(), H::HandledErr>
57    where
58        T: TryStaticCast,
59        H: EncodeErrorHandler,
60    {
61        if let Some(managed_buffer) = value.try_cast_ref::<ManagedBuffer<A>>() {
62            self.set_managed_buffer(managed_buffer);
63            Ok(())
64        } else if let Some(big_uint) = value.try_cast_ref::<BigUint<A>>() {
65            self.set_managed_buffer(&big_uint.to_bytes_be_buffer());
66            Ok(())
67        } else if let Some(big_int) = value.try_cast_ref::<BigInt<A>>() {
68            self.set_managed_buffer(&big_int.to_signed_bytes_be_buffer());
69            Ok(())
70        } else {
71            Err(h.handle_error(EncodeError::UNSUPPORTED_OPERATION))
72        }
73    }
74
75    fn start_nested_encode(&self) -> Self::NestedBuffer {
76        ManagedBufferBuilder::new_from_slice(&[])
77    }
78
79    fn finalize_nested_encode(self, nb: Self::NestedBuffer) {
80        self.set_managed_buffer(&nb.into_managed_buffer());
81    }
82}
83
84// #[inline]
85pub fn storage_set<A, T>(key: ManagedRef<'_, A, StorageKey<A>>, value: &T)
86where
87    T: TopEncode,
88    A: StorageWriteApi + ManagedTypeApi + ErrorApi,
89{
90    value
91        .top_encode_or_handle_err(
92            StorageSetOutput::new(key),
93            ExitCodecErrorHandler::<A>::from(err_msg::STORAGE_ENCODE_ERROR),
94        )
95        .unwrap_infallible()
96}
97
98/// Useful for storage mappers.
99/// Also calls to it generated by macro.
100pub fn storage_clear<A>(key: ManagedRef<'_, A, StorageKey<A>>)
101where
102    A: StorageWriteApi + ManagedTypeApi + ErrorApi,
103{
104    let value_handle: A::ManagedBufferHandle = use_raw_handle(const_handles::MBUF_CONST_EMPTY);
105    A::managed_type_impl().mb_overwrite(value_handle.clone(), &[]);
106
107    A::storage_write_api_impl().storage_store_managed_buffer_raw(key.get_handle(), value_handle);
108}
109
110/// Useful for storage mappers.
111/// Replaces the content from a key to another without decoding.
112pub fn storage_overwrite<A>(
113    from_key: ManagedRef<'_, A, StorageKey<A>>,
114    to_key: ManagedRef<'_, A, StorageKey<A>>,
115) where
116    A: StorageWriteApi + StorageReadApi + ManagedTypeApi + ErrorApi,
117{
118    let from_buffer_handle: A::ManagedBufferHandle =
119        use_raw_handle(const_handles::MBUF_TEMPORARY_1);
120
121    A::storage_read_api_impl()
122        .storage_load_managed_buffer_raw(from_key.get_handle(), from_buffer_handle.clone());
123    A::storage_write_api_impl()
124        .storage_store_managed_buffer_raw(to_key.get_handle(), from_buffer_handle);
125}