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
|
/*!
The ucd-trie crate provides a compressed trie set specifically tailored for
Unicode codepoints. The principle use case for such a trie is to represent
properties defined by Unicode that correspond to sets of Unicode codepoints.
(These properties are formally called boolean properties or "single valued"
properties. See
[UTR#23 S3.3](https://www.unicode.org/reports/tr23/#PropertyTypeDefinitions)
for more details.)
This crate has two principle types: `TrieSetOwned` and `TrieSetSlice`,
corresponding to a similar split as there is between `Vec<T>` and `&[T]`.
`TrieSetOwned` is the only way to construct a trie from a set of Unicode
codepoints.
The intended use of this library is to embed a static instance of
`TrieSetSlice` into your source code, and then use its methods as defined in
this crate to test membership. (The `ucd-generate` tool can likely generate
this code for you.)
Finally, while this crate uses the standard library by default, it provides
`no_std` functionality by disabling the `std` feature. When `no_std` is
enabled, then `TrieSetOwned` is not provided. Instead, only `TrieSetSlice` is
provided, which means `no_std` crates can still embed tries into their code.
*/
#![deny(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)]
use core::fmt;
#[cfg(feature = "std")]
pub use crate::owned::{Error, Result, TrieSetOwned};
#[cfg(test)]
#[allow(dead_code)]
mod general_category;
#[cfg(feature = "std")]
mod owned;
const CHUNK_SIZE: usize = 64;
/// A type alias for `TrieSetSlice<'static>`.
pub type TrieSet = TrieSetSlice<'static>;
/// A borrowed trie set.
#[derive(Clone, Copy)]
pub struct TrieSetSlice<'a> {
/// first tree, one level
#[doc(hidden)]
pub tree1_level1: &'a [u64],
/// second tree, first level
#[doc(hidden)]
pub tree2_level1: &'a [u8],
/// second tree, second level
#[doc(hidden)]
pub tree2_level2: &'a [u64],
/// third tree, first level
#[doc(hidden)]
pub tree3_level1: &'a [u8],
/// third tree, second level
#[doc(hidden)]
pub tree3_level2: &'a [u8],
/// third tree, third level
#[doc(hidden)]
pub tree3_level3: &'a [u64],
}
impl<'a> fmt::Debug for TrieSetSlice<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "TrieSetSlice(...)")
}
}
impl<'a> TrieSetSlice<'a> {
/// Returns true if and only if the given Unicode scalar value is in this
/// set.
pub fn contains_char(&self, c: char) -> bool {
self.contains(c as usize)
}
/// Returns true if and only if the given codepoint is in this set.
///
/// If the given value exceeds the codepoint range (i.e., it's greater
/// than `0x10FFFF`), then this returns false.
pub fn contains_u32(&self, cp: u32) -> bool {
if cp > 0x10FFFF {
return false;
}
self.contains(cp as usize)
}
#[inline(always)]
fn contains(&self, cp: usize) -> bool {
if cp < 0x800 {
self.chunk_contains(cp, self.tree1_level1[cp >> 6])
} else if cp < 0x10000 {
let leaf = match self.tree2_level1.get((cp >> 6) - 0x20) {
None => return false,
Some(&leaf) => leaf,
};
self.chunk_contains(cp, self.tree2_level2[leaf as usize])
} else {
let child = match self.tree3_level1.get((cp >> 12) - 0x10) {
None => return false,
Some(&child) => child,
};
let i = ((child as usize) * CHUNK_SIZE) + ((cp >> 6) & 0b111111);
let leaf = self.tree3_level2[i];
self.chunk_contains(cp, self.tree3_level3[leaf as usize])
}
}
#[inline(always)]
fn chunk_contains(&self, cp: usize, chunk: u64) -> bool {
((chunk >> (cp & 0b111111)) & 1) == 1
}
}
|
