gen_map 0.1.0

This crate provides customizable generational maps.
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

use crate::config::{Config, DefaultConfig};
use crate::key_piece::KeyPiece;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{Hash, Hasher};

/// A key to a value in a [`GenMap`](crate::GenMap), returned by `insert`.
pub struct Key<C: Config = DefaultConfig> {
    pub(crate) idx: C::Idx,
    pub(crate) generation: <C::Gen as KeyPiece>::NonZero,
}

impl<C: Config> Key<C> {
    /// # Safety
    ///
    /// `generation` must be odd.
    #[inline]
    pub(crate) unsafe fn from_parts_unchecked(idx: C::Idx, generation: C::Gen) -> Self {
        debug_assert!(generation.is_odd());
        Self {
            idx,
            generation: generation.into_non_zero().unwrap_unchecked(),
        }
    }
}

// The traits below are written by hand because a derive would also demand
// them from `C`, and a config is only a marker type.

impl<C: Config> Clone for Key<C> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}

impl<C: Config> Copy for Key<C> {}

impl<C: Config> PartialEq for Key<C> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.idx == other.idx && self.generation == other.generation
    }
}

impl<C: Config> Eq for Key<C> {}

impl<C: Config> PartialOrd for Key<C> {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

/// Keys are ordered by index, then by generation.
impl<C: Config> Ord for Key<C> {
    #[inline]
    fn cmp(&self, other: &Self) -> Ordering {
        self.idx
            .cmp(&other.idx)
            .then(self.generation.cmp(&other.generation))
    }
}

impl<C: Config> Hash for Key<C> {
    #[inline]
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.idx.hash(state);
        self.generation.hash(state);
    }
}

impl<C: Config> fmt::Debug for Key<C> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Key")
            .field("idx", &self.idx)
            .field("generation", &self.generation)
            .finish()
    }
}