blazemap 0.5.1

Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map.
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::{
    prelude::AllInstancesIter,
    traits::{BlazeMapId, TypeInfoContainer},
};
#[cfg(feature = "serde")]
use serde::{Serialize, Serializer};
use std::{cmp::Ordering, marker::PhantomData};

/// Provides `PartialOrd`, `Ord` and `Serialize` traits, which are derived as
/// for an original type, for [`BlazeMapId`]s in the
/// [`loom`](crate::external::loom) context.
#[derive(Debug, Copy, Clone)]
pub struct TestableId<'a, I, C> {
    id: I,
    type_info_container: &'a C,
}

impl<'a, I, C> TestableId<'a, I, C>
where
    I: BlazeMapId<TypeInfoContainer = C>,
    C: TypeInfoContainer,
{
    /// Creates a new instance of [`TestableId`].
    ///
    /// # Safety
    /// Mustn't be used outside of loom tests,
    /// since there is no guarantee that one [`BlazeMapId`]
    /// doesn't interact with different containers of the same type.
    #[inline]
    pub fn new(id: I, type_info_container: &'a C) -> Self {
        Self {
            id,
            type_info_container,
        }
    }

    /// Creates an iterator over all identifiers registered.
    #[inline]
    #[must_use]
    pub fn all_instances_iter(&self) -> AllInstancesIter<I> {
        use crate::traits::CapacityInfoProvider;
        let num_elems = self
            .type_info_container
            .capacity_info_provider()
            .offset_capacity();
        AllInstancesIter {
            range: 0..num_elems,
            phantom: PhantomData,
        }
    }
}

impl<'a, I, C> PartialEq for TestableId<'a, I, C>
where
    I: BlazeMapId<TypeInfoContainer = C> + PartialEq,
    C: TypeInfoContainer,
{
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        assert!(std::ptr::eq(
            self.type_info_container,
            other.type_info_container,
        ));
        self.id.eq(&other.id)
    }
}

impl<'a, I, C> Eq for TestableId<'a, I, C>
where
    I: BlazeMapId<TypeInfoContainer = C> + Eq,
    C: TypeInfoContainer,
{
}

impl<'a, I, C> PartialOrd for TestableId<'a, I, C>
where
    I: BlazeMapId<TypeInfoContainer = C> + PartialEq,
    C: TypeInfoContainer,
    C::OrigType: PartialOrd,
{
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        use crate::traits::KeyByOffsetProvider;
        use std::borrow::Borrow;
        assert!(std::ptr::eq(
            self.type_info_container,
            other.type_info_container,
        ));
        let guard = self.type_info_container.key_by_offset_provider();
        let (lhs, rhs) = unsafe {
            (
                guard.key_by_offset_unchecked(self.id.get_offset()),
                guard.key_by_offset_unchecked(other.id.get_offset()),
            )
        };
        lhs.borrow().partial_cmp(rhs.borrow())
    }
}

impl<'a, I, C> Ord for TestableId<'a, I, C>
where
    I: BlazeMapId<TypeInfoContainer = C> + Eq,
    C: TypeInfoContainer,
    C::OrigType: Ord,
{
    #[inline]
    fn cmp(&self, other: &Self) -> Ordering {
        use crate::traits::KeyByOffsetProvider;
        use std::borrow::Borrow;
        assert!(std::ptr::eq(
            self.type_info_container,
            other.type_info_container,
        ));
        let guard = self.type_info_container.key_by_offset_provider();
        let (lhs, rhs) = unsafe {
            (
                guard.key_by_offset_unchecked(self.id.get_offset()),
                guard.key_by_offset_unchecked(other.id.get_offset()),
            )
        };
        lhs.borrow().cmp(rhs.borrow())
    }
}

#[cfg(feature = "serde")]
impl<'a, I, C> Serialize for TestableId<'a, I, C>
where
    I: BlazeMapId<TypeInfoContainer = C>,
    C: TypeInfoContainer,
    C::OrigType: Serialize,
{
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        use crate::traits::KeyByOffsetProvider;
        use ::std::borrow::Borrow;

        unsafe {
            self.type_info_container
                .key_by_offset_provider()
                .key_by_offset_unchecked(self.id.get_offset())
                .borrow()
                .serialize(serializer)
        }
    }
}