1#![deny(2 unsafe_op_in_unsafe_fn,3 clippy::missing_safety_doc,4 clippy::undocumented_unsafe_blocks5)]6#![warn(clippy::pedantic, clippy::nursery)]7#![allow(clippy::missing_const_for_fn)]8use std::{9 borrow::Cow,10 cell::RefCell,11 fmt::{self, Display},12 hash::{BuildHasherDefault, Hash, Hasher},13 ops::Deref,14 str,15};1617use hashbrown::HashMap;18use jrsonnet_gcmodule::Trace;19use rustc_hash::FxHasher;2021mod inner;22use inner::Inner;2324252627#[derive(Clone, PartialOrd, Ord, Eq)]28pub struct IStr(Inner);29impl Trace for IStr {30 fn is_type_tracked() -> bool {31 false32 }33}3435impl IStr {36 #[must_use]37 pub fn empty() -> Self {38 "".into()39 }40 #[must_use]41 pub fn as_str(&self) -> &str {42 self as &str43 }4445 #[must_use]46 pub fn cast_bytes(self) -> IBytes {47 IBytes(self.0.clone())48 }49}5051impl Deref for IStr {52 type Target = str;5354 fn deref(&self) -> &Self::Target {55 56 unsafe { self.0.as_str_unchecked() }57 }58}5960impl PartialEq for IStr {61 fn eq(&self, other: &Self) -> bool {62 63 Inner::ptr_eq(&self.0, &other.0)64 }65}6667impl PartialEq<str> for IStr {68 fn eq(&self, other: &str) -> bool {69 self as &str == other70 }71}7273impl Hash for IStr {74 fn hash<H: Hasher>(&self, state: &mut H) {75 76 state.write_usize(Inner::as_ptr(&self.0).cast::<()>() as usize);77 }78}7980impl Drop for IStr {81 fn drop(&mut self) {82 #[cold]83 #[inline(never)]84 fn unpool(inner: &Inner) {85 86 let res = POOL.try_with(|pool| pool.borrow_mut().remove(inner));87 if res.is_ok() {88 debug_assert_eq!(Inner::strong_count(inner), 1);89 }90 }91 92 if Inner::strong_count(&self.0) <= 2 {93 unpool(&self.0);94 }95 }96}9798impl fmt::Debug for IStr {99 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {100 fmt::Debug::fmt(self as &str, f)101 }102}103104impl Display for IStr {105 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {106 fmt::Display::fmt(self as &str, f)107 }108}109110111#[derive(Clone, PartialOrd, Ord, Eq)]112pub struct IBytes(Inner);113impl Trace for IBytes {114 fn is_type_tracked() -> bool {115 false116 }117}118119impl IBytes {120 #[must_use]121 pub fn cast_str(self) -> Option<IStr> {122 if Inner::check_utf8(&self.0) {123 Some(IStr(self.0.clone()))124 } else {125 None126 }127 }128 129 130 unsafe fn cast_str_unchecked(self) -> IStr {131 132 unsafe { Inner::assume_utf8(&self.0) };133 IStr(self.0.clone())134 }135136 #[must_use]137 pub fn as_slice(&self) -> &[u8] {138 self.0.as_slice()139 }140}141142impl Deref for IBytes {143 type Target = [u8];144145 fn deref(&self) -> &Self::Target {146 self.0.as_slice()147 }148}149150impl PartialEq for IBytes {151 fn eq(&self, other: &Self) -> bool {152 153 Inner::ptr_eq(&self.0, &other.0)154 }155}156157impl Hash for IBytes {158 fn hash<H: Hasher>(&self, state: &mut H) {159 160 state.write_usize(Inner::as_ptr(&self.0).cast::<()>() as usize);161 }162}163164impl Drop for IBytes {165 fn drop(&mut self) {166 #[cold]167 #[inline(never)]168 fn unpool(inner: &Inner) {169 170 let res = POOL.try_with(|pool| pool.borrow_mut().remove(inner));171 if res.is_ok() {172 debug_assert_eq!(Inner::strong_count(inner), 1);173 }174 }175 176 if Inner::strong_count(&self.0) <= 2 {177 unpool(&self.0);178 }179 }180}181182impl fmt::Debug for IBytes {183 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {184 fmt::Debug::fmt(self as &[u8], f)185 }186}187188impl<'c> From<Cow<'c, str>> for IStr {189 fn from(v: Cow<'c, str>) -> Self {190 intern_str(&v)191 }192}193impl From<&str> for IStr {194 fn from(v: &str) -> Self {195 intern_str(v)196 }197}198impl From<String> for IStr {199 fn from(s: String) -> Self {200 s.as_str().into()201 }202}203impl From<&String> for IStr {204 fn from(s: &String) -> Self {205 s.as_str().into()206 }207}208impl From<char> for IStr {209 fn from(value: char) -> Self {210 let mut buf = [0; 5];211 Self::from(&*value.encode_utf8(&mut buf))212 }213}214impl From<&[u8]> for IBytes {215 fn from(v: &[u8]) -> Self {216 intern_bytes(v)217 }218}219220#[cfg(feature = "serde")]221impl serde::Serialize for IStr {222 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>223 where224 S: serde::Serializer,225 {226 self.as_str().serialize(serializer)227 }228}229230#[cfg(feature = "serde")]231impl<'de> serde::Deserialize<'de> for IStr {232 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>233 where234 D: serde::Deserializer<'de>,235 {236 let str = <&str>::deserialize(deserializer)?;237 Ok(intern_str(str))238 }239}240241#[cfg(feature = "structdump")]242impl structdump::Codegen for IStr {243 fn gen_code(244 &self,245 res: &mut structdump::CodegenResult,246 _unique: bool,247 ) -> structdump::TokenStream {248 let s: &str = self;249 res.add_code(250 structdump::quote! {251 structdump_import::IStr::from(#s)252 },253 Some(structdump::quote![structdump_import::IStr]),254 false,255 )256 }257}258259thread_local! {260 static POOL: RefCell<HashMap<Inner, (), BuildHasherDefault<FxHasher>>> = RefCell::new(HashMap::with_capacity_and_hasher(200, BuildHasherDefault::default()));261}262263#[must_use]264pub fn intern_bytes(bytes: &[u8]) -> IBytes {265 POOL.with(|pool| {266 let mut pool = pool.borrow_mut();267 let entry = pool.raw_entry_mut().from_key(bytes);268 match entry {269 hashbrown::hash_map::RawEntryMut::Occupied(i) => IBytes(i.get_key_value().0.clone()),270 hashbrown::hash_map::RawEntryMut::Vacant(e) => {271 let (k, _) = e.insert(Inner::new_bytes(bytes), ());272 IBytes(k.clone())273 }274 }275 })276}277278#[must_use]279pub fn intern_str(str: &str) -> IStr {280 281 unsafe { intern_bytes(str.as_bytes()).cast_str_unchecked() }282}283284#[cfg(test)]285mod tests {286 use crate::IStr;287288 #[test]289 fn simple() {290 let a = IStr::from("a");291 let b = IStr::from("a");292293 assert_eq!(a.as_ptr(), b.as_ptr());294 }295}