1use lasso::{Spur, ThreadedRodeo};
2use serde::{Deserialize, Deserializer, Serialize, Serializer};
3use std::fmt;
4use std::sync::LazyLock;
5
6static INTERNER: LazyLock<ThreadedRodeo> = LazyLock::new(ThreadedRodeo::default);
8
9#[derive(Clone, Copy, PartialEq, Eq, Hash)]
12pub struct NodeId(Spur);
13
14impl NodeId {
15 pub fn intern(s: &str) -> Self {
17 NodeId(INTERNER.get_or_intern(s))
18 }
19
20 pub fn as_str(&self) -> &str {
22 INTERNER.resolve(&self.0)
23 }
24
25 pub fn anonymous() -> Self {
27 use std::sync::atomic::{AtomicU64, Ordering};
28 static COUNTER: AtomicU64 = AtomicU64::new(0);
29 let n = COUNTER.fetch_add(1, Ordering::Relaxed);
30 Self::intern(&format!("_anon_{n}"))
31 }
32}
33
34impl fmt::Debug for NodeId {
35 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
36 write!(f, "@{}", self.as_str())
37 }
38}
39
40impl fmt::Display for NodeId {
41 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42 write!(f, "@{}", self.as_str())
43 }
44}
45
46impl Serialize for NodeId {
47 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
48 serializer.serialize_str(self.as_str())
49 }
50}
51
52impl<'de> Deserialize<'de> for NodeId {
53 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
54 let s = String::deserialize(deserializer)?;
55 Ok(NodeId::intern(&s))
56 }
57}
58
59#[cfg(test)]
60mod tests {
61 use super::*;
62
63 #[test]
64 fn interning_roundtrip() {
65 let a = NodeId::intern("login_form");
66 let b = NodeId::intern("login_form");
67 assert_eq!(a, b);
68 assert_eq!(a.as_str(), "login_form");
69 }
70
71 #[test]
72 fn anonymous_ids_are_unique() {
73 let a = NodeId::anonymous();
74 let b = NodeId::anonymous();
75 assert_ne!(a, b);
76 }
77}