use crate::{latin_1::Latin1Str, tokens::TokenKind};
use std::sync::{Arc, LazyLock, RwLock};
pub(crate) trait Arena {
type Id;
fn alloc(kind: TokenKind, value: Box<Latin1Str>) -> Symbol;
}
#[derive(Debug, Default)]
struct GlobalArena {
elements: RwLock<Vec<Arc<SymbolInner>>>,
}
static GLOBAL_ARENA: LazyLock<GlobalArena> = LazyLock::new(|| GlobalArena {
elements: RwLock::new(Vec::default()),
});
impl Arena for GlobalArena {
type Id = usize;
fn alloc(kind: TokenKind, value: Box<Latin1Str>) -> Symbol {
if let Ok(mut lock) = GLOBAL_ARENA.elements.write() {
if let Some(existing_symbol) =
lock.iter().find(|el| el.kind == kind && el.value == value)
{
Symbol::new(existing_symbol.clone())
} else {
let sym = Arc::new(SymbolInner {
value,
kind,
id: lock.len(),
});
lock.push(sym.clone());
Symbol::new(sym)
}
} else {
panic!("Multi access")
}
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub(crate) struct Symbol(Arc<SymbolInner>);
impl Symbol {
pub fn kind(&self) -> TokenKind {
self.0.kind
}
pub fn text(&self) -> &Latin1Str {
&self.0.value
}
}
#[derive(Debug)]
struct SymbolInner {
kind: TokenKind,
value: Box<Latin1Str>,
id: usize,
}
impl PartialEq for SymbolInner {
fn eq(&self, other: &Self) -> bool {
self.id == other.id
}
}
impl Eq for SymbolInner {}
impl Symbol {
fn new(inner: Arc<SymbolInner>) -> Symbol {
Symbol(inner)
}
pub fn allocate(kind: TokenKind, text: impl Into<Box<Latin1Str>>) -> Symbol {
Self::allocate_in_arena::<GlobalArena>(kind, text)
}
pub fn allocate_in_arena<A: Arena>(kind: TokenKind, text: impl Into<Box<Latin1Str>>) -> Symbol {
A::alloc(kind, text.into())
}
}