Struct PortableCapacityScope 

pub struct PortableCapacityScope {
    pub id: String,
    pub scope: PortableScope,
    pub enabled: bool,
    pub effective: bool,
    pub capacity: Option<i64>,
    pub unit: Option<String>,
    pub calculation: PortableCalculation,
    pub extensions: PortableExtensions,
    pub unknown: PortableExtensions,
}

One configured scope: its configuration, the shared calculation, and its preserved metadata (T040).

The configuration fields are the entry verbatim (capacity as the i64 the entry stores, unit, enabled), so a disabled entry’s retained ceiling is carried rather than dropped; effective is the entry’s own answer for whether a ceiling is in force. The calculation is the shared DTO, and it reports state = "unconfigured" for an entry that is not in force — the explicit state, never a zero.

extensions and unknown are the two preservation channels the module docs describe: the entry’s unknown keys live in the nested object, so one named calculation cannot shadow the real one.

Fields

id: String

The [capacity.<id>] handle the entry is stored under.

scope: PortableScope

The scope the entry names.

enabled: bool

Whether the entry is enabled.

effective: bool

Whether a ceiling is in force (enabled with a value and a unit).

capacity: Option<i64>

The ceiling the entry stores, verbatim, or null when it stores none.

unit: Option<String>

The unit the entry stores, verbatim, or null when it stores none.

calculation: PortableCalculation

The shared calculation for this scope.

extensions: PortableExtensions

The entry’s unknown keys, preserved verbatim in a namespace of their own.

unknown: PortableExtensions

Keys a newer writer placed directly on this node, preserved verbatim.

Trait Implementations

impl Clone for PortableCapacityScope

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PortableCapacityScope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PortableCapacityScope

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PortableCapacityScope

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for PortableCapacityScope

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PortableCapacityScope