multiversx_sc/storage/
storage_set.rs1use 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
84pub 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
98pub 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
110pub 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}