Struct Namespace 

pub struct Namespace {
    pub grassmannian: (usize, usize),
    pub position: SchubertClass,
    pub capabilities: Vec<Capability>,
    pub name: String,
}

A namespace: a point in a Grassmannian with associated capabilities

In ShaperOS, namespaces represent isolated execution contexts. Their position in the Grassmannian encodes their “geometric location” while their capabilities determine what operations they can perform.

Contracts

• All capabilities must be compatible with the namespace’s Grassmannian
• Capabilities must satisfy dependency ordering
• No two conflicting capabilities can coexist

Fields

grassmannian: (usize, usize)

The Grassmannian this namespace lives in: Gr(k, n)

position: SchubertClass

Schubert cell containing this namespace (its “position”)

capabilities: Vec<Capability>

Capabilities granted to this namespace

name: String

Human-readable name

Implementations

impl Namespace

pub fn new(name: impl Into<String>, position: SchubertClass) -> Self

Create a new namespace at a given Schubert position

pub fn full( name: impl Into<String>, k: usize, n: usize, ) -> EnumerativeResult<Self>

Create a namespace with full access (identity Schubert class)

Contract

requires: k < n
ensures: result.position.partition.is_empty()
ensures: result.grassmannian == (k, n)

pub fn grant(&mut self, capability: Capability) -> Result<(), NamespaceError>

Grant a capability to this namespace

Contract

requires: forall dep in capability.requires. self.has_capability(dep)
requires: forall conf in capability.conflicts. !self.has_capability(conf)
requires: forall existing in self.capabilities. !existing.conflicts.contains(capability.id)
ensures: self.has_capability(capability.id)

Errors

Returns NamespaceError::Conflict if the capability conflicts with an existing one. Returns NamespaceError::MissingDependency if a required capability is missing.

pub fn grant_all( &mut self, capabilities: Vec<Capability>, ) -> Result<(), NamespaceError>

Try to grant multiple capabilities in dependency order

This is a convenience method that attempts to grant capabilities in the order that satisfies dependencies.

pub fn revoke(&mut self, id: &CapabilityId) -> bool

Revoke a capability from this namespace

Contract

requires: no other capability depends on this one
ensures: !self.has_capability(id)

Returns true if the capability was revoked, false if it couldn’t be (either not present or has dependents).

pub fn has_capability(&self, id: &CapabilityId) -> bool

Check if this namespace has a specific capability

pub fn capability_ids(&self) -> Vec<CapabilityId>

Get all capability IDs

pub fn capability_count(&self) -> usize

Get the number of capabilities

pub fn count_configurations(&self) -> IntersectionResult

Count valid configurations satisfying all capability constraints

This computes the intersection number of the position Schubert class with all capability Schubert classes.

Contract

ensures:
  - total_codim > dim(Gr) => Empty
  - total_codim == dim(Gr) => Finite(n) where n >= 0
  - total_codim < dim(Gr) => PositiveDimensional

pub fn total_codimension(&self) -> usize

Total codimension of position plus all capabilities

pub fn would_overdetermine(&self, capability: &Capability) -> bool

Check if adding a capability would make the system overdetermined

Trait Implementations

impl Clone for Namespace

fn clone(&self) -> Namespace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Namespace

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

Formats the value using the given formatter.