doc

frame/support/src/lib.rs

@@ -1626,23 +1626,37 @@ pub mod pallet_prelude {
 /// * [`pallet_prelude::StorageValue`] expect `Value` and optionally `QueryKind` and `OnEmpty`,
 /// * [`pallet_prelude::StorageMap`] expect `Hasher`, `Key`, `Value` and optionally `QueryKind` and
 ///   `OnEmpty`,
+/// * [`pallet_prelude::CountedStorageMap`] expect `Hasher`, `Key`, `Value` and optionally
+///   `QueryKind` and `OnEmpty`,
 /// * [`pallet_prelude::StorageDoubleMap`] expect `Hasher1`, `Key1`, `Hasher2`, `Key2`, `Value` and
 ///   optionally `QueryKind` and `OnEmpty`.
 ///
 /// For unnamed generic argument: Their first generic must be `_` as it is replaced by the macro
 /// and other generic must declared as a normal declaration of type generic in rust.
 ///
-/// The Prefix generic written by the macro is generated using `PalletInfo::name::<Pallet<..>>()`
-/// and the name of the storage type.
+/// The `Prefix` generic written by the macro. It implements `StorageInstance` using
+/// `PalletInfo::name::<Pallet<..>>()` for the pallet prefix and the name of the storage type or
+/// the rename as in `#[pallet::storage_prefix = "Bar"]` for storage prefix.
 /// E.g. if runtime names the pallet "MyExample" then the storage `type Foo<T> = ...` use the
-/// prefix: `Twox128(b"MyExample") ++ Twox128(b"Foo")`.
+/// pallet prefix: "MyExample" and the storage prefix "Foo".
+///
+/// NOTE: Storages use those prefixes so that values are stored after the key
+/// `Twox128(b"MyExample") ++ Twox128(b"Foo")`.
+///
+/// For the `CountedStorageMap` variant, the Prefix also implements `CountedStorageMapInstance`.
+/// It associate a `CounterPrefix`, which is implemented same as above, but the storage prefix is
+/// prepend with `"CounterFor"`.
 ///
 /// The optional attribute `#[pallet::getter(fn $my_getter_fn_name)]` allow to define a
 /// getter function on `Pallet`.
 ///
+/// The optional attribute `#[pallet::storage_prefix = "SomeName"]` allow to define the storage
+/// prefix to use, see how `Prefix` generic is implemented above.
+///
 /// E.g:
 /// ```ignore
 /// #[pallet::storage]
+/// #[pallet::storage_prefix = "foo"]
 /// #[pallet::getter(fn my_storage)]
 /// pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
 /// ```
@@ -1679,6 +1693,8 @@ pub mod pallet_prelude {
 /// `_GeneratedPrefixForStorage$NameOfStorage`, and implements
 /// [`StorageInstance`](traits::StorageInstance) on it using the pallet and storage name. It then
 /// uses it as the first generic of the aliased type.
+/// For `CountedStorageMap`, `CountedStorageMapInstance` is implemented, and another similar struct
+/// is generated.
 ///
 /// For named generic, the macro will reorder the generics, and remove the names.
 ///
@@ -1966,6 +1982,7 @@ pub mod pallet_prelude {
 ///
 /// 	// Another storage declaration
 /// 	#[pallet::storage]
+/// 	#[pallet::storage_prefix = "SomeName"]
 /// 	#[pallet::getter(fn my_storage)]
 /// 	pub(super) type MyStorage<T> =
 /// 		StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;

frame/support/src/storage/types/counted_map.rs

@@ -17,8 +17,8 @@ use frame_metadata::{
 };
 use max_encoded_len::MaxEncodedLen;
 
-/// A wrapper around a `StorageMap` and a `StorageValue<u32>` to keep track of how many items are in
-/// a map, without needing to iterate all the values.
+/// A wrapper around a `StorageMap` and a `StorageValue<Value=u32>` to keep track of how many items
+/// are in a map, without needing to iterate all the values.
 ///
 /// This storage item has additional storage read and write overhead when manipulating values
 /// compared to a regular storage map.
@@ -29,8 +29,6 @@ use max_encoded_len::MaxEncodedLen;
 ///
 /// Whenever the counter needs to be updated, an additional read and write occurs to update that
 /// counter.
-///
-/// The storage prefix for the storage value is the given prefix concatenated with `"Counter"`.
 pub struct CountedStorageMap<
 	Prefix, Hasher, Key, Value, QueryKind=OptionQuery, OnEmpty=GetDefault, MaxValues=GetDefault,
 >(