Now let's take a silly one
1use std::sync::Arc;
2
3use knot_types::{AccountDid, OwnerDid, RepoDid, RepoRkey};
4use lasso::{Spur, ThreadedRodeo};
5
6macro_rules! interned {
7 ($name:ident) => {
8 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
9 pub(crate) struct $name(Spur);
10 };
11}
12
13interned!(AccountKey);
14interned!(RepoKey);
15interned!(OwnerKey);
16interned!(RkeyKey);
17
18#[derive(Debug, Clone, Default)]
19pub(crate) struct Interner(Arc<ThreadedRodeo>);
20
21impl Interner {
22 pub(crate) fn new() -> Self {
23 Self(Arc::new(ThreadedRodeo::new()))
24 }
25
26 pub(crate) fn intern_account(&self, did: &AccountDid) -> AccountKey {
27 AccountKey(self.0.get_or_intern(did.as_str()))
28 }
29
30 pub(crate) fn account(&self, did: &AccountDid) -> Option<AccountKey> {
31 self.0.get(did.as_str()).map(AccountKey)
32 }
33
34 pub(crate) fn resolve_account(&self, key: AccountKey) -> AccountDid {
35 AccountDid::new(self.0.resolve(&key.0)).expect("interned account DID is valid account DID")
36 }
37
38 pub(crate) fn intern_repo(&self, repo: &RepoDid) -> RepoKey {
39 RepoKey(self.0.get_or_intern(repo.as_str()))
40 }
41
42 pub(crate) fn repo(&self, repo: &RepoDid) -> Option<RepoKey> {
43 self.0.get(repo.as_str()).map(RepoKey)
44 }
45
46 pub(crate) fn resolve_repo(&self, key: RepoKey) -> RepoDid {
47 RepoDid::new(self.0.resolve(&key.0)).expect("interned repo DID is valid repo DID")
48 }
49
50 pub(crate) fn intern_owner(&self, owner: &OwnerDid) -> OwnerKey {
51 OwnerKey(self.0.get_or_intern(owner.as_str()))
52 }
53
54 pub(crate) fn owner(&self, owner: &OwnerDid) -> Option<OwnerKey> {
55 self.0.get(owner.as_str()).map(OwnerKey)
56 }
57
58 pub(crate) fn resolve_owner(&self, key: OwnerKey) -> OwnerDid {
59 OwnerDid::new(self.0.resolve(&key.0)).expect("interned owner DID is valid owner DID")
60 }
61
62 pub(crate) fn intern_rkey(&self, rkey: &RepoRkey) -> RkeyKey {
63 RkeyKey(self.0.get_or_intern(rkey.as_str()))
64 }
65
66 pub(crate) fn rkey(&self, rkey: &RepoRkey) -> Option<RkeyKey> {
67 self.0.get(rkey.as_str()).map(RkeyKey)
68 }
69
70 pub(crate) fn resolve_rkey(&self, key: RkeyKey) -> RepoRkey {
71 RepoRkey::new(self.0.resolve(&key.0)).expect("interned rkey is valid rkey")
72 }
73}