Enum CacheScope 

pub enum CacheScope {
    Shared,
    User(String),
}

Trust/visibility scope for a cached CRDT state entry.

Cached state holds the same kind of data — opaque serialized Store state — regardless of where they came from. They differ only in provenance, which determines who is allowed to see them:

• Shared: state the daemon materialized itself via a local Transaction. The daemon is the trusted computer, so these bytes are good for any user with read permission on the database. Encrypted stores never land here (the daemon has no encryptor key — see crate::store::PasswordStore), so shared state is always plaintext.

• User(uuid): state a specific user computed and published over the service wire. The daemon cannot verify the merge result, so it is scoped to that user only — alice’s publication is invisible to bob. This is where encrypted-store materializations live (the client decrypts, merges, re-encrypts, and publishes the ciphertext).

On read, the wire handler resolves User(session_user) first and falls back to Shared on miss — so a remote read of an unencrypted store benefits from cross-user dedup via the shared scope, while encrypted store reads only ever hit user-scoped cached state.

Variants

Shared

Daemon-computed; visible to every user with database read permission.

User(String)

Client-uploaded; visible only to the named user.

Implementations

impl CacheScope

pub fn storage_key(&self) -> Option<&str>

Storage key for the scope — None encodes Self::Shared, Some encodes Self::User. Useful for backends that need a single nullable column or a uniform key prefix (e.g. SQL primary keys, Redis key formatting).

Trait Implementations

impl Clone for CacheScope

fn clone(&self) -> CacheScope

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CacheScope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CacheScope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CacheScope

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CacheScope

fn eq(&self, other: &CacheScope) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CacheScope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CacheScope

impl StructuralPartialEq for CacheScope