Struct ObjectContext 

pub struct ObjectContext {
    pub usecase: String,
    pub scopes: Scopes,
}

Defines where an object belongs within the object store.

This is part of the full object identifier, see ObjectId.

Fields

usecase: String

The usecase, or “product” this object belongs to.

This can be defined on-the-fly by the client, but special server logic (such as the concrete backend/bucket) can be tied to this as well.

scopes: Scopes

The scopes of the object, used for compartmentalization and authorization.

Scopes are hierarchical key-value pairs that act as containers for objects. The first, top-level scope can contain sub scopes, like a structured nested folder system. As such, scopes are used for isolation and access authorization.

Ordering

Note that the order of scopes matters! For example, organization=17,project=42 indicates that project 42 is part of organization 17. If an object were created with these scopes reversed, it counts as a different object.

Not every object within a usecase needs to have the same scopes. It is perfectly valid to create objects with disjunct or a subset of scopes. However, by convention, we recommend to use the same scopes for all objects within a usecase where possible.

Creation

To create scopes, collect from an iterator of Scopes. Since scopes must be validated, you must use Scope::create to create them:

use objectstore_service::id::ObjectContext;
use objectstore_types::scope::{Scope, Scopes};

let object_id = ObjectContext {
    usecase: "my_usecase".to_string(),
    scopes: Scopes::from_iter([
        Scope::create("organization", "17").unwrap(),
        Scope::create("project", "42").unwrap(),
    ]),
};

Trait Implementations

impl Clone for ObjectContext

fn clone(&self) -> ObjectContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ObjectContext

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

Formats the value using the given formatter.

impl Hash for ObjectContext

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 ObjectContext

fn eq(&self, other: &ObjectContext) -> 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 Eq for ObjectContext

impl StructuralPartialEq for ObjectContext