Struct PortableCapacityDocument 

pub struct PortableCapacityDocument {
    pub format: String,
    pub version: u32,
    pub scopes: Vec<PortableCapacityScope>,
    pub snapshots: Vec<PortableCapacitySnapshot>,
    pub history: Vec<PortableCapacityHistoryEvent>,
    pub diagnostics: Vec<PortableCapacityDiagnostic>,
    pub extensions: PortableExtensions,
    pub unknown: PortableExtensions,
}

Everything the local capacity surfaces know, in one versioned document.

Fields

format: String

The format marker: FORMAT.

version: u32

The format version: VERSION.

scopes: Vec<PortableCapacityScope>

One row per configured scope, in [capacity] declaration order.

snapshots: Vec<PortableCapacitySnapshot>

Every closed cycle’s immutable evidence, in snapshot order.

history: Vec<PortableCapacityHistoryEvent>

Every capacity lifecycle event, in cycle order then file (append) order.

diagnostics: Vec<PortableCapacityDiagnostic>

Document-level findings (preserved metadata, unsupported remote fields, version).

extensions: PortableExtensions

Document-level keys this build preserved, in a namespace of their own.

unknown: PortableExtensions

Keys a newer writer placed directly on the document, preserved verbatim.

Implementations

impl PortableCapacityDocument

pub fn build( config: &Config, root: &Path, index: &ScheduleIndex, snapshot: &IssueSnapshot, ) -> Result<Self>

Build the whole local capacity document: every configured scope with its calculation, every closed cycle’s evidence, every capacity lifecycle event, and the remote-target diagnostics.

snapshot is the one-pass issue snapshot the caller already built with index (the same pair tix capacity calculate uses), so a scope’s numbers are the shared calculation’s and a multi-scope export still indexes the issues once (NFR-001). The read path touches the snapshot store and the cycle records and writes nothing.

pub fn build_for_cycle( config: &Config, root: &Path, index: &ScheduleIndex, snapshot: &IssueSnapshot, reference: &str, ) -> Result<Self>

Build the document for one cycle: the scope that configures it, its immutable evidence and its lifecycle history.

The reference is what the caller wrote — a generated cycle’s name or its stable id — and it is folded through the same adapter every other surface uses, so the two spellings select one document (C-003). A reference nothing resolves to is a not_found, not an empty document.

pub fn is_empty(&self) -> bool

Whether this document carries no capacity at all.

pub fn format(&self) -> &str

The document’s format marker.

pub const fn version(&self) -> u32

The document’s format version.

pub fn insert_extension(&mut self, key: impl Into<String>, value: Value)

Preserve one document-level key, in the nested extensions object.

The only public write path into a bag, and it cannot produce a document this build cannot read: the key lands in a namespace of its own, so it can never duplicate — or be read in place of — a document field.

pub fn to_json(&self) -> Result<String>

Serialize the document as compact JSON.

pub fn to_json_pretty(&self) -> Result<String>

Serialize the document as pretty JSON — the export surface’s shape.

pub fn from_json(raw: &str) -> Result<Self>

Read a document back.

The [Marker] is read first: a document that is not a capacity document is refused by name (its format marker) rather than by whatever shape error its fields happened to raise — a tix-health or tix-roadmap payload overlaps structurally and used to produce a misleading field error. A document of another version is read, its own fields and preserved keys kept, and the mismatch is merged into the diagnostics once — the checked-and-reported third answer between refusing a newer writer and silently dropping its fields.

Trait Implementations

impl Clone for PortableCapacityDocument

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 PortableCapacityDocument

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PortableCapacityDocument

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PortableCapacityDocument

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for PortableCapacityDocument

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 PortableCapacityDocument