Enum CacheScope 

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

Trust/visibility scope for a cached CRDT state entry.

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

• Shared: bytes the daemon computed itself via a local Transaction. The daemon is the trusted computer; these bytes are good for any user with read permission on the database. Populated automatically as a side effect of Database::get_store_state and other daemon-side materialization paths. Encrypted stores never land here (daemon has no encryptor key — see crate::store::PasswordStore), so Shared entries are always plaintext.

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

On read, the wire handler tries 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 entries.

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