Merge pull request #1931 from multiversx/managemap-encoded

ManagedMapEncoded - new impl

Author: andrei-marinica

framework/base/src/types/managed/wrapped.rs

@@ -12,6 +12,7 @@ mod managed_address;
 mod managed_buffer_read_to_end;
 mod managed_byte_array;
 mod managed_decimal;
+mod managed_map_encoded;
 mod managed_option;
 mod managed_ref;
 mod managed_ref_mut;
@@ -46,6 +47,7 @@ pub use managed_byte_array::ManagedByteArray;
 pub use managed_decimal::{
     ConstDecimals, Decimals, ManagedDecimal, ManagedDecimalSigned, NumDecimals,
 };
+pub use managed_map_encoded::ManagedMapEncoded;
 pub use managed_option::ManagedOption;
 pub use managed_ref::ManagedRef;
 pub use managed_ref_mut::ManagedRefMut;

framework/base/src/types/managed/wrapped/managed_map_encoded.rs

@@ -0,0 +1,129 @@
+use multiversx_sc_codec::{TopDecode, TopEncode};
+use unwrap_infallible::UnwrapInfallible;
+
+use crate::api::{const_handles, ErrorApi, ManagedTypeApi};
+use crate::contract_base::ExitCodecErrorHandler;
+use crate::err_msg;
+use crate::types::{ManagedBuffer, ManagedMap, ManagedRefMut};
+use core::marker::PhantomData;
+
+/// A managed map that works with any serializable key and value types.
+///
+/// It encodes both when saving, and decodes the value when getting.
+///
+/// ## Empty encodings
+///
+/// Just like the base ManagedMap, it makes no difference between a missing key
+/// and a key with a corresponding empty encoded value.
+///
+/// So, for instance, here `contains` returns false, because `0` is encoded as an empty buffer:
+///
+/// ```no_run
+/// # let mut mme = multiversx_sc::types::ManagedMapEncoded::<multiversx_sc::api::uncallable::UncallableApi, i32, i32>::new();
+/// # let key = 1;
+/// mme.put(&key, &0);
+/// assert!(!mme.contains(&key));
+/// ```
+#[derive(Default)]
+pub struct ManagedMapEncoded<M, K, V>
+where
+    M: ManagedTypeApi,
+{
+    pub(super) raw_map: ManagedMap<M>,
+    _phantom: PhantomData<(K, V)>,
+}
+
+impl<M, K, V> ManagedMapEncoded<M, K, V>
+where
+    M: ManagedTypeApi,
+{
+    #[inline]
+    fn from_raw_map(raw_map: ManagedMap<M>) -> Self {
+        ManagedMapEncoded {
+            raw_map,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn new() -> Self {
+        ManagedMapEncoded::from_raw_map(ManagedMap::new())
+    }
+}
+
+impl<M, K, V> ManagedMapEncoded<M, K, V>
+where
+    M: ManagedTypeApi + ErrorApi,
+    K: TopEncode,
+    V: TopEncode + TopDecode,
+{
+    /// Retrieves and decodes value associated with key.
+    pub fn get(&self, key: &K) -> V {
+        let temp_key = temp_key_encode(key);
+        let value_raw = self.raw_map.get(&temp_key);
+        value_decode(value_raw)
+    }
+
+    /// Since both the key and value are encoded before saving to the map, there is no need to take them owned.
+    pub fn put(&mut self, key: &K, value: &V) {
+        let temp_key = temp_key_encode(key);
+        let temp_value = temp_value_encode(value);
+        self.raw_map.put(&temp_key, &temp_value);
+    }
+
+    /// Clears value associated with key, and returns old value.
+    pub fn remove(&mut self, key: &K) -> V {
+        let temp_key = temp_key_encode(key);
+        let value_raw = self.raw_map.remove(&temp_key);
+        value_decode(value_raw)
+    }
+
+    /// Returns true if there is a non-empty encoded value associated with the key.
+    pub fn contains(&self, key: &K) -> bool {
+        let temp_key = temp_key_encode(key);
+        self.raw_map.contains(&temp_key)
+    }
+}
+
+fn temp_key_encode<M, K>(key: &K) -> ManagedRefMut<'static, M, ManagedBuffer<M>>
+where
+    M: ManagedTypeApi + ErrorApi,
+    K: TopEncode,
+{
+    let mut key_ref = unsafe { ManagedBuffer::temp_const_ref_mut(const_handles::MBUF_TEMPORARY_1) };
+    key_ref.overwrite(&[]);
+    key.top_encode_or_handle_err(
+        &mut *key_ref,
+        ExitCodecErrorHandler::<M>::from(err_msg::SERIALIZER_ENCODE_ERROR),
+    )
+    .unwrap_infallible();
+    key_ref
+}
+
+fn temp_value_encode<M, V>(value: &V) -> ManagedRefMut<'static, M, ManagedBuffer<M>>
+where
+    M: ManagedTypeApi + ErrorApi,
+    V: TopEncode,
+{
+    let mut value_ref =
+        unsafe { ManagedBuffer::temp_const_ref_mut(const_handles::MBUF_TEMPORARY_2) };
+    value_ref.overwrite(&[]);
+    value
+        .top_encode_or_handle_err(
+            &mut *value_ref,
+            ExitCodecErrorHandler::<M>::from(err_msg::SERIALIZER_ENCODE_ERROR),
+        )
+        .unwrap_infallible();
+    value_ref
+}
+
+fn value_decode<M, V>(value_raw: ManagedBuffer<M>) -> V
+where
+    M: ManagedTypeApi + ErrorApi,
+    V: TopDecode,
+{
+    V::top_decode_or_handle_err(
+        value_raw,
+        ExitCodecErrorHandler::<M>::from(err_msg::SERIALIZER_ENCODE_ERROR),
+    )
+    .unwrap_infallible()
+}

framework/scenario/tests/managed_map_encoded_test.rs

@@ -0,0 +1,200 @@
+use multiversx_sc::api::ManagedTypeApi;
+use multiversx_sc::codec::derive::{NestedDecode, NestedEncode, TopDecode, TopEncode};
+use multiversx_sc::codec::{self, DecodeDefault, EncodeDefault};
+use multiversx_sc::proxy_imports::{TopDecodeOrDefault, TopEncodeOrDefault};
+use multiversx_sc::types::{BigUint, ManagedBuffer, ManagedMapEncoded};
+use multiversx_sc_scenario::api::StaticApi;
+
+type ManagedMapEncodedBig =
+    ManagedMapEncoded<StaticApi, BigUint<StaticApi>, ManagedBuffer<StaticApi>>;
+
+fn assert_missing_key_int(mme: &ManagedMapEncoded<StaticApi, i32, i64>, key: i32) {
+    assert!(!mme.contains(&key));
+    assert_eq!(mme.get(&key), 0);
+}
+
+#[test]
+fn managed_map_encoded_int_test() {
+    let key = 1;
+    let mut mme = ManagedMapEncoded::<StaticApi, i32, i64>::new();
+
+    assert_missing_key_int(&mme, key);
+
+    let value = 10;
+
+    mme.put(&key, &value);
+    assert!(mme.contains(&key));
+    assert_eq!(mme.get(&key), value);
+
+    assert_eq!(mme.remove(&key), value);
+    assert_missing_key_int(&mme, key);
+
+    assert_eq!(mme.remove(&key), 0);
+    assert_missing_key_int(&mme, key);
+
+    let value = 0;
+
+    mme.put(&key, &value);
+    assert_missing_key_int(&mme, key);
+
+    assert_eq!(mme.remove(&key), 0);
+    assert_missing_key_int(&mme, key);
+}
+
+fn assert_missing_key_big(mme: &ManagedMapEncodedBig, key: &BigUint<StaticApi>) {
+    assert!(!mme.contains(key));
+    assert_eq!(mme.get(key), ManagedBuffer::new());
+}
+
+#[test]
+fn managed_map_encoded_big_test() {
+    let mut mme =
+        ManagedMapEncoded::<StaticApi, BigUint<StaticApi>, ManagedBuffer<StaticApi>>::new();
+
+    let key = BigUint::from(1u32);
+    assert_missing_key_big(&mme, &key);
+
+    let value = ManagedBuffer::from("abc");
+    let empty = ManagedBuffer::new();
+
+    mme.put(&key, &value);
+    assert!(mme.contains(&key));
+    assert_eq!(&mme.get(&key), &value);
+
+    assert_eq!(&mme.remove(&key), &value);
+    assert_missing_key_big(&mme, &key);
+
+    assert_eq!(&mme.remove(&key), &empty);
+    assert_missing_key_big(&mme, &key);
+
+    mme.put(&key, &empty);
+    assert_missing_key_big(&mme, &key);
+
+    assert_eq!(&mme.remove(&key), &empty);
+    assert_missing_key_big(&mme, &key);
+}
+
+#[derive(TopEncode, TopDecode)]
+pub struct StructKey {
+    a: i32,
+    b: i32,
+}
+
+#[derive(NestedEncode, NestedDecode, PartialEq, Debug)]
+pub struct StructValue<M: ManagedTypeApi> {
+    x: i32,
+    y: ManagedBuffer<M>,
+}
+
+fn assert_missing_opt_struct(
+    mme: &ManagedMapEncoded<StaticApi, StructKey, Option<StructValue<StaticApi>>>,
+    key: &StructKey,
+) {
+    assert!(!mme.contains(key));
+    assert_eq!(mme.get(key), None);
+}
+
+#[test]
+fn managed_map_encoded_opt_struct_test() {
+    let mut mme = ManagedMapEncoded::<StaticApi, StructKey, Option<StructValue<StaticApi>>>::new();
+
+    let key = StructKey { a: 1, b: 2 };
+    assert_missing_opt_struct(&mme, &key);
+
+    let value = Some(StructValue {
+        x: 3,
+        y: ManagedBuffer::from("abc"),
+    });
+
+    mme.put(&key, &value);
+    assert!(mme.contains(&key));
+    assert_eq!(&mme.get(&key), &value);
+
+    assert_eq!(&mme.remove(&key), &value);
+    assert_missing_opt_struct(&mme, &key);
+
+    assert_eq!(&mme.remove(&key), &None);
+    assert_missing_opt_struct(&mme, &key);
+
+    mme.put(&key, &None);
+    assert_missing_opt_struct(&mme, &key);
+
+    assert_eq!(&mme.remove(&key), &None);
+    assert_missing_opt_struct(&mme, &key);
+}
+
+#[derive(TopEncode, TopDecode)]
+pub struct ManagedStructKey<M: ManagedTypeApi> {
+    a: BigUint<M>,
+    b: BigUint<M>,
+}
+
+#[derive(TopEncodeOrDefault, TopDecodeOrDefault, PartialEq, Debug)]
+pub struct StructValueOrDefault<M: ManagedTypeApi> {
+    x: i32,
+    y: ManagedBuffer<M>,
+}
+
+impl<M: ManagedTypeApi> EncodeDefault for StructValueOrDefault<M> {
+    fn is_default(&self) -> bool {
+        self.x == 0
+    }
+}
+
+impl<M: ManagedTypeApi> DecodeDefault for StructValueOrDefault<M> {
+    fn default() -> Self {
+        StructValueOrDefault {
+            x: 0,
+            y: ManagedBuffer::new(),
+        }
+    }
+}
+
+fn assert_missing_struct(
+    mme: &ManagedMapEncoded<
+        StaticApi,
+        ManagedStructKey<StaticApi>,
+        StructValueOrDefault<StaticApi>,
+    >,
+    key: &ManagedStructKey<StaticApi>,
+) {
+    assert!(!mme.contains(key));
+    assert_eq!(mme.get(key), StructValueOrDefault::default());
+}
+
+#[test]
+fn managed_map_encoded_struct_or_default_test() {
+    let mut mme = ManagedMapEncoded::<
+        StaticApi,
+        ManagedStructKey<StaticApi>,
+        StructValueOrDefault<StaticApi>,
+    >::new();
+
+    let key = ManagedStructKey {
+        a: 1u32.into(),
+        b: 2u32.into(),
+    };
+    assert_missing_struct(&mme, &key);
+
+    let value = StructValueOrDefault {
+        x: 3,
+        y: ManagedBuffer::from("abc"),
+    };
+    let default = StructValueOrDefault::default();
+
+    mme.put(&key, &value);
+    assert!(mme.contains(&key));
+    assert_eq!(&mme.get(&key), &value);
+
+    assert_eq!(&mme.remove(&key), &value);
+    assert_missing_struct(&mme, &key);
+
+    assert_eq!(&mme.remove(&key), &default);
+    assert_missing_struct(&mme, &key);
+
+    mme.put(&key, &default);
+    assert_missing_struct(&mme, &key);
+
+    assert_eq!(&mme.remove(&key), &default);
+    assert_missing_struct(&mme, &key);
+}