ty_map_gen 0.1.6

A type projecting map generator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::any::TypeId;
use std::borrow::Borrow;
use std::cmp::Ordering;
use std::hash::Hash;

pub trait DualKeyIndex<T: ?Sized> {
    fn ty(&self) -> TypeId;
    fn name(&self) -> &T;
}

impl<T: ?Sized> PartialEq for dyn DualKeyIndex<T> + '_
where
    T: PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        self.ty() == other.ty() && self.name() == other.name()
    }
}

impl<T: ?Sized> Eq for dyn DualKeyIndex<T> + '_ where T: Eq {}

impl<T: ?Sized> PartialOrd for dyn DualKeyIndex<T> + '_
where
    T: PartialOrd,
{
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        match self.ty().cmp(&other.ty()) {
            Ordering::Equal => self.name().partial_cmp(other.name()),
            order => Some(order),
        }
    }
}

impl<T: ?Sized> Ord for dyn DualKeyIndex<T> + '_
where
    T: Ord,
{
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.ty()
            .cmp(&other.ty())
            .then(self.name().cmp(other.name()))
    }
}

impl<T: ?Sized> Hash for dyn DualKeyIndex<T> + '_
where
    T: Hash,
{
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.ty().hash(state);
        self.name().hash(state);
    }
}

impl<A, T: ?Sized> DualKeyIndex<T> for (TypeId, A)
where
    A: Borrow<T>,
{
    fn ty(&self) -> TypeId {
        self.0
    }

    fn name(&self) -> &T {
        self.1.borrow()
    }
}
impl<'a, A, T: ?Sized> Borrow<dyn DualKeyIndex<T> + 'a> for (TypeId, A)
where
    A: Borrow<T> + 'a,
{
    fn borrow(&self) -> &(dyn DualKeyIndex<T> + 'a) {
        self
    }
}