Struct fadroma::storage::TypedKey

pub struct TypedKey<'a, T: Segment + ?Sized>(_);

A strongly-typed key with segments defined by the concrete type which must implement Segment. For typed keys which consist of multiple types use TypedKey2, TypedKey3 and TypedKey4. Constructs the key in order of definition.

Examples

use fadroma::{
    cosmwasm_std::testing::mock_dependencies,
    storage::{Key, ItemSpace, TypedKey2}
};
 
fadroma::namespace!(NumbersNs, b"numbers");
 
// Storage for u64 numbers with a key that consists of b"numbers" + a string + a byte.
const NUMBERS: ItemSpace::<u64, NumbersNs, TypedKey2<String, u8>> = ItemSpace::new();
 
let mut deps = mock_dependencies();
let storage = deps.as_mut().storage;
 
let string_segment = "hello".to_string();
let number_segment = 33u8;
 
NUMBERS.save(storage, (&string_segment, &number_segment), &1).unwrap();
 
// Can also be constructed like this
let key = TypedKey2::from((&string_segment, &number_segment));
NUMBERS.save(storage, key.clone(), &1).unwrap();
 
let mut bytes: Vec<u8> = Vec::with_capacity(key.size());
key.write_segments(&mut bytes);
 
assert_eq!(
    bytes,
    [string_segment.as_bytes(), &number_segment.to_be_bytes()].concat()
);

Trait Implementations

impl<'a, T: Clone + Segment + ?Sized> Clone for TypedKey<'a, T>

fn clone(&self) -> TypedKey<'a, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, T: Debug + Segment + ?Sized> Debug for TypedKey<'a, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T: Segment + ?Sized> From<&'a T> for TypedKey<'a, T>

fn from(value: &'a T) -> Self

Converts to this type from the input type.

impl<'a, T: Hash + Segment + ?Sized> Hash for TypedKey<'a, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T: Segment + ?Sized> Key for TypedKey<'a, T>

fn size(&self) -> usize

fn write_segments(&self, buf: &mut Vec<u8>)

impl<'a, T: PartialEq + Segment + ?Sized> PartialEq<TypedKey<'a, T>> for TypedKey<'a, T>

fn eq(&self, other: &TypedKey<'a, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T: Copy + Segment + ?Sized> Copy for TypedKey<'a, T>

impl<'a, T: Segment + ?Sized> StructuralPartialEq for TypedKey<'a, T>