cl-structures: Fully remove unused arenas v2 sources
This commit is contained in:
parent
12046fa9f7
commit
e7c5a02afa
@ -1,130 +0,0 @@
|
|||||||
//! A global intern pool for strings, represented by the [Sym] symbol
|
|
||||||
|
|
||||||
use super::{intern::Interner, symbol::Symbol};
|
|
||||||
use std::{
|
|
||||||
fmt::Display,
|
|
||||||
num::NonZeroU32,
|
|
||||||
sync::{OnceLock, RwLock},
|
|
||||||
};
|
|
||||||
|
|
||||||
/// Holds a globally accessible [Interner] which uses [Sym] as its [Symbol]
|
|
||||||
static GLOBAL_INTERNER: OnceLock<RwLock<Interner<Sym>>> = OnceLock::new();
|
|
||||||
|
|
||||||
/// A unique identifier corresponding to a particular globally-interned [String].
|
|
||||||
///
|
|
||||||
/// Copies of that string can be obtained with [Sym::get] or [String::try_from].
|
|
||||||
///
|
|
||||||
/// New strings can be interned with [Sym::new] or [Sym::from]
|
|
||||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
|
||||||
pub struct Sym(NonZeroU32);
|
|
||||||
|
|
||||||
impl Sym {
|
|
||||||
/// Gets the interned [Sym] for the given value, or interns a new one.
|
|
||||||
///
|
|
||||||
/// # Blocks
|
|
||||||
/// This conversion blocks if the Global Interner lock is held.
|
|
||||||
///
|
|
||||||
/// # May Panic
|
|
||||||
/// Panics if the Global Interner's lock has been poisoned by a panic in another thread
|
|
||||||
pub fn new(value: &str) -> Self {
|
|
||||||
GLOBAL_INTERNER
|
|
||||||
.get_or_init(Default::default)
|
|
||||||
.write()
|
|
||||||
.expect("global interner should not be poisoned in another thread")
|
|
||||||
.get_or_insert(value)
|
|
||||||
}
|
|
||||||
/// Gets a [Sym] associated with the given string, if one already exists
|
|
||||||
pub fn try_from_str(value: &str) -> Option<Self> {
|
|
||||||
GLOBAL_INTERNER.get()?.read().ok()?.get(value)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Gets a copy of the value of the [Sym]
|
|
||||||
// TODO: Make this copy-less
|
|
||||||
pub fn get(self) -> Option<String> {
|
|
||||||
String::try_from(self).ok()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Looks up the string associated with this [Sym],
|
|
||||||
/// and performs a transformation on it if it exists.
|
|
||||||
pub fn map<T>(&self, f: impl Fn(&str) -> T) -> Option<T> {
|
|
||||||
Some(f(GLOBAL_INTERNER.get()?.read().ok()?.get_str(*self)?))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Display for Sym {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
let Some(interner) = GLOBAL_INTERNER.get() else {
|
|
||||||
return write!(f, "[sym@{} (uninitialized)]", self.0);
|
|
||||||
};
|
|
||||||
let Ok(interner) = interner.read() else {
|
|
||||||
return write!(f, "[sym@{} (poisoned)]", self.0);
|
|
||||||
};
|
|
||||||
let Some(str) = interner.get_str(*self) else {
|
|
||||||
return write!(f, "[sym@{} (invalid)]", self.0);
|
|
||||||
};
|
|
||||||
str.fmt(f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Symbol for Sym {
|
|
||||||
const MAX: usize = u32::MAX as usize - 1;
|
|
||||||
fn try_from_usize(value: usize) -> Option<Self> {
|
|
||||||
Some(Self(NonZeroU32::try_from_usize(value)?))
|
|
||||||
}
|
|
||||||
fn into_usize(self) -> usize {
|
|
||||||
self.0.into_usize()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: AsRef<str>> From<T> for Sym {
|
|
||||||
/// Converts to this type from the input type.
|
|
||||||
///
|
|
||||||
/// # Blocks
|
|
||||||
/// This conversion blocks if the Global Interner lock is held.
|
|
||||||
///
|
|
||||||
/// # May Panic
|
|
||||||
/// Panics if the Global Interner's lock has been poisoned by a panic in another thread
|
|
||||||
fn from(value: T) -> Self {
|
|
||||||
Self::new(value.as_ref())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl TryFrom<Sym> for String {
|
|
||||||
type Error = SymError;
|
|
||||||
|
|
||||||
fn try_from(value: Sym) -> Result<Self, Self::Error> {
|
|
||||||
let Some(interner) = GLOBAL_INTERNER.get() else {
|
|
||||||
Err(SymError::Uninitialized)?
|
|
||||||
};
|
|
||||||
let Ok(interner) = interner.write() else {
|
|
||||||
Err(SymError::Poisoned)?
|
|
||||||
};
|
|
||||||
match interner.get_str(value) {
|
|
||||||
None => Err(SymError::Unseen(value)),
|
|
||||||
Some(string) => Ok(string.into()),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Describes an error in [Sym] to [String] lookup
|
|
||||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
||||||
pub enum SymError {
|
|
||||||
Uninitialized,
|
|
||||||
Poisoned,
|
|
||||||
Unseen(Sym),
|
|
||||||
}
|
|
||||||
impl std::error::Error for SymError {}
|
|
||||||
impl Display for SymError {
|
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
||||||
match self {
|
|
||||||
SymError::Uninitialized => "String pool was not initialized".fmt(f),
|
|
||||||
SymError::Poisoned => "String pool was held by panicking thread".fmt(f),
|
|
||||||
SymError::Unseen(sym) => {
|
|
||||||
write!(f, "Symbol {sym:?} not present in String pool")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests;
|
|
||||||
@ -1,34 +0,0 @@
|
|||||||
//! Tests for the global intern pool
|
|
||||||
use super::*;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn globalsym_from_returns_unique_value_for_unique_keys() {
|
|
||||||
let foo_bar = Sym::from("foo_bar");
|
|
||||||
let foo_baz = Sym::from("foo_baz");
|
|
||||||
assert_ne!(foo_bar, foo_baz);
|
|
||||||
assert_eq!(foo_bar, Sym::from("foo_bar"));
|
|
||||||
assert_eq!(foo_baz, Sym::from("foo_baz"));
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn try_from_str_returns_none_before_init() {
|
|
||||||
if let Some(value) = Sym::try_from_str("") {
|
|
||||||
panic!("{value}")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[test]
|
|
||||||
fn try_from_str_returns_some_when_key_exists() {
|
|
||||||
let _ = Sym::from("foo_bar");
|
|
||||||
assert!(dbg!(Sym::try_from_str("foo_bar")).is_some());
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn try_from_str_returns_the_same_thing_as_globalsym_from() {
|
|
||||||
let foo_bar = Sym::from("foo_bar");
|
|
||||||
assert_eq!(Some(foo_bar), Sym::try_from_str("foo_bar"));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn map_works() {
|
|
||||||
let foo_bar = Sym::from("foo_bar");
|
|
||||||
assert!(foo_bar.map(|sym| "foo_bar" == sym).unwrap());
|
|
||||||
}
|
|
||||||
@ -1,49 +0,0 @@
|
|||||||
//! A string interner with deduplication
|
|
||||||
|
|
||||||
use super::{string_arena::StringArena, symbol::Symbol};
|
|
||||||
use hashbrown::hash_table::HashTable;
|
|
||||||
use std::hash::{BuildHasher, RandomState};
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct Interner<Sym: Symbol, H: BuildHasher = RandomState> {
|
|
||||||
set: HashTable<Sym>,
|
|
||||||
arena: StringArena<Sym>,
|
|
||||||
hasher: H,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Sym: Symbol, H: BuildHasher + Default> Default for Interner<Sym, H> {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self { set: Default::default(), arena: Default::default(), hasher: Default::default() }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<Sym: Symbol, H: BuildHasher> Interner<Sym, H> {
|
|
||||||
pub fn get_or_insert(&mut self, s: &str) -> Sym {
|
|
||||||
let Self { set: map, arena, hasher } = self;
|
|
||||||
let hash = hasher.hash_one(s);
|
|
||||||
*map.entry(hash, is_match(s, arena), |t| {
|
|
||||||
hasher.hash_one(arena.get(*t).unwrap())
|
|
||||||
})
|
|
||||||
.or_insert_with(|| arena.push_string(s))
|
|
||||||
.get()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn get(&self, s: &str) -> Option<Sym> {
|
|
||||||
let Self { set: map, arena, hasher } = self;
|
|
||||||
map.find(hasher.hash_one(s), is_match(s, arena)).copied()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn get_str(&self, sym: Sym) -> Option<&str> {
|
|
||||||
self.arena.get(sym)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn is_match<'a, Sym: Symbol>(
|
|
||||||
s: &'a str,
|
|
||||||
arena: &'a StringArena<Sym>,
|
|
||||||
) -> impl Fn(&Sym) -> bool + 'a {
|
|
||||||
move |sym| match arena.get(*sym) {
|
|
||||||
Some(sym) => sym == s,
|
|
||||||
None => false,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,48 +0,0 @@
|
|||||||
//! Compactly stores a set of immutable strings, producing a [Symbol] for each one
|
|
||||||
use super::symbol::Symbol;
|
|
||||||
use std::marker::PhantomData;
|
|
||||||
/// Compactly stores a set of immutable strings, producing a [Symbol] for each one
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct StringArena<T: Symbol> {
|
|
||||||
ends: Vec<usize>,
|
|
||||||
buf: String,
|
|
||||||
_t: PhantomData<fn(T)>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Symbol> StringArena<T> {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
Default::default()
|
|
||||||
}
|
|
||||||
/// # May panic
|
|
||||||
/// Panics if Symbol::from_usize would panic
|
|
||||||
fn next_key(&self) -> T {
|
|
||||||
Symbol::from_usize(self.ends.len())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn get_span(&self, key: T) -> Option<(usize, usize)> {
|
|
||||||
let key = key.into_usize();
|
|
||||||
Some((*self.ends.get(key - 1)?, *self.ends.get(key)?))
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn get(&self, key: T) -> Option<&str> {
|
|
||||||
let (start, end) = self.get_span(key)?;
|
|
||||||
// Safety: start and end offsets were created by push_string
|
|
||||||
Some(unsafe { self.buf.get_unchecked(start..end) })
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn push_string(&mut self, s: &str) -> T {
|
|
||||||
if self.ends.is_empty() {
|
|
||||||
self.ends.push(self.buf.len())
|
|
||||||
}
|
|
||||||
let key = self.next_key();
|
|
||||||
self.buf.push_str(s);
|
|
||||||
self.ends.push(self.buf.len());
|
|
||||||
key
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Symbol> Default for StringArena<T> {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self { ends: Default::default(), buf: Default::default(), _t: PhantomData }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,35 +0,0 @@
|
|||||||
use std::{fmt, hash, num::*};
|
|
||||||
|
|
||||||
pub trait Symbol: Copy + fmt::Debug + fmt::Display + Eq + hash::Hash {
|
|
||||||
/// The largest [`usize`] that may be stored in the [Symbol]
|
|
||||||
const MAX: usize;
|
|
||||||
/// Returns [`Some(Self)`](Some) if `value` is in range 0..=[Symbol::MAX]
|
|
||||||
fn try_from_usize(value: usize) -> Option<Self>;
|
|
||||||
/// # May Panic
|
|
||||||
/// May panic if `value` is not in range 0..=[Symbol::MAX]
|
|
||||||
fn from_usize(value: usize) -> Self {
|
|
||||||
Self::try_from_usize(value).expect("should be within MIN and MAX")
|
|
||||||
}
|
|
||||||
fn into_usize(self) -> usize;
|
|
||||||
}
|
|
||||||
|
|
||||||
#[rustfmt::skip]
|
|
||||||
impl Symbol for usize {
|
|
||||||
const MAX: usize = usize::MAX;
|
|
||||||
fn try_from_usize(value: usize) -> Option<Self> { Some(value) }
|
|
||||||
fn into_usize(self) -> usize { self }
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! impl_symbol_for_nonzero{($($int:ident: $nonzero:ident),* $(,)?) => {$(
|
|
||||||
impl Symbol for $nonzero {
|
|
||||||
const MAX: usize = $int::MAX as usize - 1;
|
|
||||||
fn try_from_usize(value: usize) -> Option<Self> {
|
|
||||||
$nonzero::try_from(value.wrapping_add(1) as $int).ok()
|
|
||||||
}
|
|
||||||
fn into_usize(self) -> usize {
|
|
||||||
self.get() as usize - 1
|
|
||||||
}
|
|
||||||
}
|
|
||||||
)*}}
|
|
||||||
|
|
||||||
impl_symbol_for_nonzero!(u8: NonZeroU8, u16: NonZeroU16, u32: NonZeroU32, u64: NonZeroU64, usize: NonZeroUsize);
|
|
||||||
Loading…
Reference in New Issue
Block a user