Struct CloneBounds 

pub struct CloneBounds;

CloneBounds is used to bound keys or values stored in hashmap to cloneable types.

use std::sync::Arc;
use typedmap::{TypedMap, TypedMapKey};
use typedmap::clone::{clone_box, CloneBounds};
let mut map: TypedMap::<(), CloneBounds, CloneBounds, _> = TypedMap::default();

#[derive(PartialEq, Eq, Hash, Debug)]
struct Key;

#[derive(Clone, Eq, PartialEq, Hash, Debug)]
struct CloneKey;

impl TypedMapKey for Key {
    type Value = u32;
}

impl TypedMapKey for CloneKey {
    type Value = u32;
}

map.insert(CloneKey, 32);
// Won't compile, because Key is not Clone
// map.insert(Key, 32);

for elem in map.iter() {
    let cloned = clone_box(elem.key_container_ref());
    let key = *cloned.as_any_box().downcast::<CloneKey>().unwrap();
    assert_eq!(key, CloneKey);

    let cloned = clone_box(elem.value_container_ref());
    let value = *cloned.as_any_box().downcast::<u32>().unwrap();
    assert_eq!(value, 32);
}

Trait Implementations

impl Bounds for CloneBounds

type KeyContainer = dyn ContainerWithHashAndClone<CloneBounds>

Type used to store keys with those bounds. It should be dyn ContainerWithHash<Self> + Marker traits

type Container = dyn CloneAny

Type used to store values that fulfill specified bounds (e.g. dyn Any + Send + Sync or dyn CloneAny)

fn as_any(this: &Self::Container) -> &dyn Any

fn as_any_mut(this: &mut Self::Container) -> &mut dyn Any

fn as_any_box(this: Box<Self::Container>) -> Box<dyn Any>

impl<T: CloneAny + Any> HasBounds<T> for CloneBounds

fn cast_box(this: Box<T>) -> Box<Self::Container>

Converts from Box<T> to Box<Container>

fn as_ref(this: &T) -> &Self::Container

Converts from &T to &Container

fn as_mut(this: &mut T) -> &mut Self::Container

Converts from &mut T to &mut Container

fn cast_key_box(this: Box<T>) -> Box<Self::KeyContainer>

where T: 'static + Sized + Hash + Eq,

Converts from Box<T> to Box<KeyContainer>

fn box_key(this: T) -> Box<Self::KeyContainer>

where T: 'static + Sized + Hash + Eq,

Boxes key of type T as Box<KeyContainer>

fn box_value(this: T) -> Box<Self::Container>

where Self: Sized,

Boxes value of type T as Box<Container>

fn downcast_ref(this: &Self::Container) -> Option<&T>

where Self: 'static + Sized,

Attempts to downcast &Container to &T

fn downcast_mut(this: &mut Self::Container) -> Option<&mut T>

where Self: 'static + Sized,

Attempts to downcast &mut Container to &mut T

fn downcast_box( this: Box<Self::Container>, ) -> Result<Box<T>, Box<Self::Container>>

where Self: 'static + Sized,

Attempts to downcast Box<Container> to Box<T>