tinystr 0.2.0

A small ASCII-only bounded length string representation.
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

use std::cmp::Ordering;
use std::convert::Into;
use std::fmt;
use std::num::NonZeroU128;
use std::ops::Deref;
use std::ptr::copy_nonoverlapping;
use std::str::FromStr;

use crate::Error;

/// A tiny string that is from 1 to 16 non-NUL ASCII characters.
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct TinyStr16(NonZeroU128);

impl TinyStr16 {
    #[inline(always)]
    pub const unsafe fn new_unchecked(text: u128) -> Self {
        Self(NonZeroU128::new_unchecked(u128::from_le(text)))
    }

    #[inline(always)]
    pub fn as_str(&self) -> &str {
        self.deref()
    }

    pub fn to_ascii_uppercase(self) -> Self {
        let word = self.0.get();
        let result = word
            & !(((word + 0x1f1f1f1f_1f1f1f1f_1f1f1f1f_1f1f1f1f)
                & !(word + 0x05050505_05050505_05050505_05050505)
                & 0x80808080_80808080_80808080_80808080)
                >> 2);
        unsafe { Self(NonZeroU128::new_unchecked(result)) }
    }

    pub fn to_ascii_lowercase(self) -> Self {
        let word = self.0.get();
        let result = word
            | (((word + 0x3f3f3f3f_3f3f3f3f_3f3f3f3f_3f3f3f3f)
                & !(word + 0x25252525_25252525_25252525_25252525)
                & 0x80808080_80808080_80808080_80808080)
                >> 2);
        unsafe { Self(NonZeroU128::new_unchecked(result)) }
    }

    pub fn is_ascii_alphanumeric(self) -> bool {
        let word = self.0.get();
        let mask =
            (word + 0x7f7f7f7f_7f7f7f7f_7f7f7f7f_7f7f7f7f) & 0x80808080_80808080_80808080_80808080;
        let lower = word | 0x20202020_20202020_20202020_20202020;
        ((!(lower + 0x1f1f1f1f_1f1f1f1f_1f1f1f1f_1f1f1f1f)
            | (lower + 0x05050505_05050505_05050505_05050505))
            & mask)
            == 0
    }

    pub fn to_ascii_titlecase(self) -> Self {
        let word = self.0.get().to_le();
        let mask = ((word + 0x3f3f3f3f_3f3f3f3f_3f3f3f3f_3f3f3f1f)
            & !(word + 0x25252525_25252525_25252525_25252505)
            & 0x80808080_80808080_80808080_80808080)
            >> 2;
        let result = (word | mask) & !(0x20 & mask);
        unsafe { Self(NonZeroU128::new_unchecked(u128::from_le(result))) }
    }
}

impl fmt::Display for TinyStr16 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.deref())
    }
}

impl fmt::Debug for TinyStr16 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self.deref())
    }
}

impl Deref for TinyStr16 {
    type Target = str;

    #[inline(always)]
    fn deref(&self) -> &str {
        // Again, could use #cfg to hand-roll a big-endian implementation.
        let word = self.0.get().to_le();
        let len = (16 - word.leading_zeros() / 8) as usize;
        unsafe {
            let slice = core::slice::from_raw_parts(&self.0 as *const _ as *const u8, len);
            std::str::from_utf8_unchecked(slice)
        }
    }
}

impl PartialEq<&str> for TinyStr16 {
    fn eq(&self, other: &&str) -> bool {
        self.deref() == *other
    }
}

impl PartialOrd for TinyStr16 {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for TinyStr16 {
    fn cmp(&self, other: &Self) -> Ordering {
        self.0.get().to_be().cmp(&other.0.get().to_be())
    }
}

impl FromStr for TinyStr16 {
    type Err = Error;

    #[inline(always)]
    fn from_str(text: &str) -> Result<Self, Self::Err> {
        let len = text.len();
        if len < 1 || len > 16 {
            return Err(Error::InvalidSize);
        }
        unsafe {
            let mut word: u128 = 0;
            copy_nonoverlapping(text.as_ptr(), &mut word as *mut u128 as *mut u8, len);
            let mask = 0x80808080_80808080_80808080_80808080u128 >> (8 * (16 - len));
            // TODO: could do this with #cfg(target_endian), but this is clearer and
            // more confidence-inspiring.
            let mask = u128::from_le(mask);
            if (word & mask) != 0 {
                return Err(Error::NonAscii);
            }
            if ((mask - word) & mask) != 0 {
                return Err(Error::InvalidNull);
            }
            Ok(Self(NonZeroU128::new_unchecked(word)))
        }
    }
}

impl Into<u128> for TinyStr16 {
    fn into(self) -> u128 {
        self.0.get().to_le()
    }
}