string-hash-interner 0.20.0

Efficient string interner with minimal memory footprint and fast access to the underlying strings.
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

use core::{ffi::CStr, fmt::Debug, hash::Hash};

/// Trait implemented by different types of strings that can be interned.
///
/// # Safety
///
/// It should be alwas valid to reinterpret bytes of `Self` as `&[Self::Primitive]`
/// using [`Intern::as_bytes`].
///
/// It should be valid to reinterpret bytes copied from [`Intern::as_bytes`].
/// as `&Self` using [`Intern::from_bytes`]. Even if they were moved in memory.
pub unsafe trait Intern: Hash + PartialEq + Eq {
    /// A primitive type that has the same alignment as `Self`.
    type Primitive: Sized + Copy + Debug;

    fn as_bytes(&self) -> &[Self::Primitive];

    /// # Safety
    ///
    /// See [Safety section](Intern#safety) in the trait doc.
    unsafe fn from_bytes(bytes: &[Self::Primitive]) -> &Self;
}

unsafe impl Intern for str {
    type Primitive = u8;

    fn as_bytes(&self) -> &[u8] {
        str::as_bytes(self)
    }

    unsafe fn from_bytes(bytes: &[u8]) -> &Self {
        // SAFETY: Calling this function is only valid with bytes obtained from `Self::as_bytes`.
        unsafe { core::str::from_utf8_unchecked(bytes) }
    }
}

unsafe impl Intern for CStr {
    type Primitive = u8;

    fn as_bytes(&self) -> &[u8] {
        CStr::to_bytes_with_nul(self)
    }

    unsafe fn from_bytes(bytes: &[u8]) -> &Self {
        // SAFETY: Calling this function is only valid with bytes obtained from `Self::as_bytes`.
        unsafe { CStr::from_bytes_with_nul_unchecked(bytes) }
    }
}

unsafe impl Intern for [u8] {
    type Primitive = u8;

    fn as_bytes(&self) -> &[u8] {
        self
    }

    unsafe fn from_bytes(bytes: &[u8]) -> &Self {
        bytes
    }
}

unsafe impl Intern for [char] {
    type Primitive = char;

    fn as_bytes(&self) -> &[char] {
        self
    }

    unsafe fn from_bytes(bytes: &[char]) -> &Self {
        bytes
    }
}

#[cfg(feature = "std")]
mod std_impls {
    use super::Intern;
    use std::ffi::OsStr;

    unsafe impl Intern for OsStr {
        type Primitive = u8;

        fn as_bytes(&self) -> &[u8] {
            OsStr::as_encoded_bytes(self)
        }

        unsafe fn from_bytes(bytes: &[u8]) -> &Self {
            // SAFETY: Calling this function is only valid with bytes obtained from `Self::as_bytes`.
            unsafe { OsStr::from_encoded_bytes_unchecked(bytes) }
        }
    }
}

// TODO: add impl for `[std::ascii::Char]` when stable.