Struct ResolvedDomain 

pub struct ResolvedDomain {
    pub domain: Domain,
    pub features: Vec<DomainMember>,
    pub surfaces: Surfaces,
    pub moments: Vec<MomentRef>,
    pub claim_refs: Vec<ClaimRef>,
    pub use_case_refs: Vec<UseCaseRef>,
    pub counts: DomainCounts,
    pub evidence: FeatureEvidence,
}

One domain, resolved: the record as its file declares it, and everything derived from the stable features that name it.

The declared record is flattened, so a reader sees one object: the domain’s own fields beside its derived members and counts.

use majordomus_cli::product::{Domain, DomainCounts, FeatureEvidence, ResolvedDomain, Surfaces};
let domain: Domain = serde_json::from_value(serde_json::json!({
    "id": "context", "title": "Context", "status": "stable",
    "headline": "h", "problem": "p",
}))
.unwrap();
let resolved = ResolvedDomain {
    domain,
    features: vec![],
    surfaces: Surfaces::default(),
    moments: vec![],
    claim_refs: vec![],
    use_case_refs: vec![],
    counts: DomainCounts::default(),
    evidence: FeatureEvidence::default(),
};
let v = serde_json::to_value(&resolved).unwrap();
assert_eq!(v["id"], "context", "the record is flattened into the resolved view");
assert_eq!(v["counts"]["features"], 0);

Fields

domain: Domain

The record as its file declares it, plus its route and source.

features: Vec<DomainMember>

Derived: the stable features that name it, in presentation order.

surfaces: Surfaces

Derived: the interfaces any of its features is exposed through.

moments: Vec<MomentRef>

Derived: the operational moments its features answer, in the catalogue’s order.

claim_refs: Vec<ClaimRef>

Derived: the distinct claims its features name, with their status and test.

use_case_refs: Vec<UseCaseRef>

Derived: the distinct use cases its features name.

counts: DomainCounts

Derived: how much stands behind it.

evidence: FeatureEvidence

Derived: what is guaranteed, by claim status.

Trait Implementations

impl Clone for ResolvedDomain

fn clone(&self) -> ResolvedDomain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedDomain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResolvedDomain

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ResolvedDomain

impl JsonSchema for ResolvedDomain

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for ResolvedDomain

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

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 ResolvedDomain