intern-mint 0.3.0

byte slice interning
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

use std::{
    borrow::Cow,
    ffi::OsStr,
    fmt::{Debug, Display, Formatter},
    ops::Deref,
    path::Path,
};

use bstr::{BStr, BString, ByteSlice};

use crate::{borrow::BorrowedInterned, interned::Interned};

impl BorrowedInterned {
    pub fn as_bstr(&self) -> &BStr {
        BStr::new(self.deref())
    }

    pub fn as_path(&self) -> Cow<'_, Path> {
        self.as_bstr().to_path_lossy()
    }

    pub fn as_os_str(&self) -> Cow<'_, OsStr> {
        self.as_bstr().to_os_str_lossy()
    }

    pub fn as_str(&self) -> Cow<'_, str> {
        self.as_bstr().to_str_lossy()
    }
}

impl Display for Interned {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        Display::fmt(self as &BorrowedInterned, f)
    }
}

impl Display for BorrowedInterned {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        Display::fmt(self.as_bstr(), f)
    }
}

impl Debug for Interned {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        Debug::fmt(self as &BorrowedInterned, f)
    }
}

impl Debug for BorrowedInterned {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        Debug::fmt(self.as_bstr(), f)
    }
}

impl From<&BStr> for Interned {
    fn from(value: &BStr) -> Self {
        Self::new(value.as_ref())
    }
}

impl From<BString> for Interned {
    fn from(value: BString) -> Self {
        value.as_bstr().into()
    }
}