feat: object(generic type) to id mapper

contracts/feature-tests/basic-features/src/basic_features_main.rs

@@ -27,6 +27,7 @@ pub mod storage_mapper_linked_list;
 pub mod storage_mapper_map;
 pub mod storage_mapper_map_storage;
 pub mod storage_mapper_non_fungible_token;
+pub mod storage_mapper_object_to_id;
 pub mod storage_mapper_queue;
 pub mod storage_mapper_set;
 pub mod storage_mapper_single;
@@ -77,6 +78,7 @@ pub trait BasicFeatures:
     + non_zero_features::TypeFeatures
     + multiversx_sc_modules::default_issue_callbacks::DefaultIssueCallbacksModule
     + storage_mapper_get_at_address::StorageMapperGetAtAddress
+    + storage_mapper_object_to_id::ObjectToIdMapperFeatures
 {
     #[init]
     fn init(&self) {}

contracts/feature-tests/basic-features/src/storage_mapper_object_to_id.rs

@@ -0,0 +1,64 @@
+use crate::types::ExampleStructManaged;
+
+multiversx_sc::imports!();
+
+#[multiversx_sc::module]
+pub trait ObjectToIdMapperFeatures {
+    #[endpoint]
+    fn object_to_id_mapper_get_id(&self, object: ExampleStructManaged<Self::Api>) -> AddressId {
+        self.object_ids().get_id(&object)
+    }
+
+    #[endpoint]
+    fn object_to_id_mapper_get_id_non_zero(
+        &self,
+        object: ExampleStructManaged<Self::Api>,
+    ) -> AddressId {
+        self.object_ids().get_id_non_zero(&object)
+    }
+
+    #[endpoint]
+    fn object_to_id_mapper_get_object(
+        &self,
+        object_id: ObjectId,
+    ) -> Option<ExampleStructManaged<Self::Api>> {
+        self.object_ids().get_object(object_id)
+    }
+
+    #[endpoint]
+    fn object_to_id_mapper_contains(&self, object_id: ObjectId) -> bool {
+        self.object_ids().contains_id(object_id)
+    }
+
+    #[endpoint]
+    fn object_to_id_mapper_set(&self, object: &ExampleStructManaged<Self::Api>) -> AddressId {
+        self.object_ids().insert_new(object)
+    }
+
+    #[endpoint]
+    fn object_to_id_mapper_get_id_or_insert(
+        &self,
+        object: ExampleStructManaged<Self::Api>,
+    ) -> AddressId {
+        self.object_ids().get_id_or_insert(object)
+    }
+
+    #[endpoint]
+    fn object_to_id_mapper_remove_by_id(
+        &self,
+        object_id: ObjectId,
+    ) -> Option<ExampleStructManaged<Self::Api>> {
+        self.object_ids().remove_by_id(object_id)
+    }
+
+    #[endpoint]
+    fn address_to_id_mapper_remove_by_address(
+        &self,
+        object: ExampleStructManaged<Self::Api>,
+    ) -> AddressId {
+        self.object_ids().remove_by_object(&object)
+    }
+
+    #[storage_mapper("object_ids")]
+    fn object_ids(&self) -> ObjectToIdMapper<Self::Api, ExampleStructManaged<Self::Api>>;
+}

framework/base/src/storage/mappers.rs

@@ -4,6 +4,7 @@ mod linked_list_mapper;
 mod map_mapper;
 mod map_storage_mapper;
 mod mapper;
+mod object_to_id_mapper;
 mod ordered_binary_tree_mapper;
 mod queue_mapper;
 mod set_mapper;
@@ -21,6 +22,7 @@ pub use linked_list_mapper::{LinkedListMapper, LinkedListNode};
 pub use map_mapper::MapMapper;
 pub use map_storage_mapper::MapStorageMapper;
 pub use mapper::{StorageClearable, StorageMapper};
+pub use object_to_id_mapper::{ObjectId, ObjectToIdMapper};
 pub use ordered_binary_tree_mapper::{
     NodeId, OrderedBinaryTreeMapper, OrderedBinaryTreeNode, NULL_NODE_ID,
 };

framework/base/src/storage/mappers/object_to_id_mapper.rs

@@ -0,0 +1,199 @@
+use core::{borrow::Borrow, marker::PhantomData};
+
+use multiversx_sc_codec::{NestedDecode, NestedEncode, TopDecode, TopEncode};
+
+use crate::{
+    api::StorageMapperApi,
+    imports::{ErrorApiImpl, ManagedType},
+    storage::StorageKey,
+    storage_clear, storage_set,
+};
+
+use super::{
+    set_mapper::{CurrentStorage, StorageAddress},
+    StorageMapper,
+};
+
+static ID_SUFFIX: &[u8] = b"id";
+static OBJECT_SUFFIX: &[u8] = b"object";
+static UNKNOW_OBJECT_ERR_MSG: &[u8] = b"Unknown object";
+static LAST_ID_SUFFIX: &[u8] = b"lastId";
+
+pub type ObjectId = u64;
+pub const NULL_ID: ObjectId = 0;
+
+pub struct ObjectToIdMapper<SA, T, A = CurrentStorage>
+where
+    SA: StorageMapperApi,
+    A: StorageAddress<SA>,
+    T: TopEncode + TopDecode + NestedEncode + NestedDecode + 'static,
+{
+    _phantom_api: PhantomData<SA>,
+    _phantom_item: PhantomData<T>,
+    address: A,
+    base_key: StorageKey<SA>,
+}
+
+impl<SA, T> StorageMapper<SA> for ObjectToIdMapper<SA, T, CurrentStorage>
+where
+    SA: StorageMapperApi,
+    T: TopEncode + TopDecode + NestedEncode + NestedDecode,
+{
+    #[inline]
+    fn new(base_key: StorageKey<SA>) -> Self {
+        ObjectToIdMapper {
+            _phantom_api: PhantomData,
+            _phantom_item: PhantomData,
+            address: CurrentStorage,
+            base_key,
+        }
+    }
+}
+
+impl<SA, T, A> ObjectToIdMapper<SA, T, A>
+where
+    SA: StorageMapperApi,
+    A: StorageAddress<SA>,
+    T: TopEncode + TopDecode + NestedEncode + NestedDecode,
+{
+    pub fn contains_id(&self, id: ObjectId) -> bool {
+        let key = self.id_to_object_key(id);
+        self.address.address_storage_get_len(key.as_ref()) != 0
+    }
+
+    pub fn get_id<BT>(&self, object: BT) -> ObjectId
+    where
+        BT: Borrow<T>,
+    {
+        let key = self.object_to_id_key(object);
+        self.address.address_storage_get(key.as_ref())
+    }
+
+    pub fn get_id_non_zero<BT>(&self, object: BT) -> ObjectId
+    where
+        BT: Borrow<T>,
+    {
+        let id = self.get_id(object);
+        if id == NULL_ID {
+            SA::error_api_impl().signal_error(UNKNOW_OBJECT_ERR_MSG);
+        }
+        id
+    }
+
+    pub fn get_object(&self, id: ObjectId) -> Option<T> {
+        let key = self.id_to_object_key(id);
+        if self.address.address_storage_get_len(key.as_ref()) == 0 {
+            return None;
+        }
+        let object = self.address.address_storage_get(key.as_ref());
+        Some(object)
+    }
+
+    fn id_to_object_key(&self, id: ObjectId) -> StorageKey<SA> {
+        let mut item_key = self.base_key.clone();
+        item_key.append_bytes(ID_SUFFIX);
+        item_key.append_item(&id);
+
+        item_key
+    }
+
+    fn object_to_id_key<BT>(&self, object: BT) -> StorageKey<SA>
+    where
+        BT: Borrow<T>,
+    {
+        let mut item_key = self.base_key.clone();
+        item_key.append_bytes(OBJECT_SUFFIX);
+        item_key.append_item(object.borrow());
+
+        item_key
+    }
+
+    fn last_id_key(&self) -> StorageKey<SA> {
+        let mut item_key = self.base_key.clone();
+        item_key.append_bytes(LAST_ID_SUFFIX);
+
+        item_key
+    }
+
+    pub fn get_last_id(&self) -> ObjectId {
+        self.address
+            .address_storage_get(self.last_id_key().as_ref())
+    }
+}
+
+impl<SA, T> ObjectToIdMapper<SA, T, CurrentStorage>
+where
+    SA: StorageMapperApi,
+    T: TopEncode + TopDecode + NestedEncode + NestedDecode,
+{
+    pub fn get_id_or_insert(&self, object: T) -> ObjectId {
+        let current_id = self
+            .address
+            .address_storage_get(self.object_to_id_key(&object).as_ref());
+        if current_id != 0 {
+            return current_id;
+        }
+
+        self.insert_object(object)
+    }
+
+    pub fn insert_new<BT>(&self, object: BT) -> ObjectId
+    where
+        BT: Borrow<T>,
+    {
+        let existing_id = self.get_id(object.borrow());
+        if existing_id != NULL_ID {
+            SA::error_api_impl().signal_error(b"Object already exists");
+        }
+
+        self.insert_object(object)
+    }
+
+    pub fn remove_by_id(&self, id: ObjectId) -> Option<T> {
+        let object = self.get_object(id)?;
+        self.remove_entry(id, &object);
+
+        Some(object)
+    }
+
+    pub fn remove_by_object<BT>(&self, object: BT) -> ObjectId
+    where
+        BT: Borrow<T>,
+    {
+        let current_id = self.get_id(object.borrow());
+        if current_id != NULL_ID {
+            self.remove_entry(current_id, object);
+        }
+
+        current_id
+    }
+
+    fn insert_object<BT>(&self, object: BT) -> ObjectId
+    where
+        BT: Borrow<T>,
+    {
+        let new_id = self.get_last_id() + 1;
+        storage_set(self.id_to_object_key(new_id).as_ref(), &object.borrow());
+        storage_set(self.object_to_id_key(object).as_ref(), &new_id);
+
+        self.set_last_id(new_id);
+
+        new_id
+    }
+
+    fn set_last_id(&self, last_id: ObjectId) {
+        if last_id == 0 {
+            SA::error_api_impl().signal_error(b"ID Overflow");
+        }
+
+        storage_set(self.last_id_key().as_ref(), &last_id);
+    }
+
+    fn remove_entry<BT>(&self, id: ObjectId, object: BT)
+    where
+        BT: Borrow<T>,
+    {
+        storage_clear(self.object_to_id_key(object).as_ref());
+        storage_clear(self.id_to_object_key(id).as_ref());
+    }
+}