memo_architecture_variability

SysML API

Public namespace	memo::architecture::variability
Declared package	memo_architecture_variability
Source	src/architecture/variability/memo_variability.sysml

Namespace hierarchy

memo → memo::architecture → memo::architecture::variability

Packages

Package
memo_architecture_variability

Imports

Visibility	Target
private	Metaobjects::SemanticMetadata
private	ScalarValues::*
private	memo_core_common::*
private	memo_core_enumerations::*
private	memo_core_relationships::*

Declarations

Name	SysML kind	Description	Specializes
ProductFeature	part def	Product feature definition specializing MemoPart.	MemoPart
RequiresFeature	connection def	Selecting the source feature needs the target feature selected too.	MemoRelationship
ExcludesFeature	connection def	The two features cannot be selected together. Symmetric: either end may be written first.	MemoRelationship
RealizesFeature	metadata def	#RealizesFeature dependency from <variant> to <feature>; The variant exists to give the family this feature.	MemoTypedDependency
SelectsFeature	metadata def	#SelectsFeature dependency from <release> to <feature>, <feature>; The release contains the variants that realize these features.	MemoTypedDependency
ShowsView	metadata def	#ShowsView dependency from <feature> to <view>, <view>; The views the feature's viewpoint lists: chosen for what the feature demonstrates, not found by a rule.	MemoTypedDependency

ProductFeature

part def ProductFeature specializes MemoPart

Property	Value
Description	Product feature definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_architecture_variability

RequiresFeature

connection def RequiresFeature :> MemoRelationship

Property	Value
Description	Selecting the source feature needs the target feature selected too.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_variability

ExcludesFeature

connection def ExcludesFeature :> MemoRelationship

Property	Value
Description	The two features cannot be selected together. Symmetric: either end may be written first.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_variability

RealizesFeature

metadata def RealizesFeature :> MemoTypedDependency

Property	Value
Description	#RealizesFeature dependency from <variant> to <feature>; The variant exists to give the family this feature.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_architecture_variability

SelectsFeature

metadata def SelectsFeature :> MemoTypedDependency

Property	Value
Description	#SelectsFeature dependency from <release> to <feature>, <feature>; The release contains the variants that realize these features.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_architecture_variability

ShowsView

metadata def ShowsView :> MemoTypedDependency

Property	Value
Description	#ShowsView dependency from <feature> to <view>, <view>; The views the feature's viewpoint lists: chosen for what the feature demonstrates, not found by a rule.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_architecture_variability

Source

architecture/variability/memo_variability.sysml

// Features and design options.
//
// A design option is native SysML: a `variation` (a definition or a usage whose
// body holds only `variant` members; SysML-textual-bnf.kebnf:224 for the definition
// prefix, :282 for the usage prefix, :254-256 the variant member). MEMO adds
// nothing to how one is written. What SysML has no word for is WHY a variant exists
// and WHICH ones go together: that is a product feature.
//
//   part featEuMarket : ProductFeature;                    // the market EU releases target
//   variation part energyOutput : LogicalComponent {
//       variant part euOutput : LogicalComponent;          // a variant, for the EU
//       variant part usOutput : LogicalComponent;
//   }
//   #RealizesFeature dependency from energyOutput::euOutput to featEuMarket;
//   connection : RequiresFeature connect ...               // one feature needs another
//
// A release selects features (`#SelectsFeature`), and through them the variants it
// contains; a rule counts one variant per variation point from that. A feature is
// a usage like any other part, named by the family, and a platform package may
// declare the family's features once.
//
// A variation point cannot own attributes: SysIDE rejects an owned feature in a
// variation (`usage-variation-owned-feature-membership`). Identity metadata is an
// annotation and is allowed (measured on E0, 2026-10-13); `status` and anything else
// a variation point would carry goes on its variants.
package memo_architecture_variability {
    private import Metaobjects::SemanticMetadata;
    private import ScalarValues::*;

    private import memo_core_common::*;
    private import memo_core_enumerations::*;
    private import memo_core_relationships::*;

    // Named ProductFeature, not Feature: `Feature` is the KerML metaclass, and the
    // builder falls back to a metaclass name for a kind it cannot place.
    //
    // A feature's page is what is said about it: its prose is the element's `doc`, and
    // the analysis is these four statements, each optional until someone has an answer.
    // What the feature shows is curated: `#ShowsView` below names its views.
    part def ProductFeature specializes MemoPart {
        /** What the feature gives the people who use the product, in a sentence or two. */
        attribute valueProposition : String[0..1];
        /** Who it is for: the roles or segments that gain from it. */
        attribute targetUsers : String[0..1];
        /** How anyone will know it worked: the measure, and the level that counts as success. */
        attribute successMeasure : String[0..1];
        /** What has to hold for the value to be real, and what is not yet known. */
        attribute assumptions : String[0..1];
    }

    // `Requires` is taken by the native `require` relation, so these say what they join.
    connection def RequiresFeature :> MemoRelationship {
        doc /* Selecting the source feature needs the target feature selected too. */
        end dependentFeature : ProductFeature :>> source;
        end requiredFeature : ProductFeature :>> target;
    }
    abstract connection requiresFeatureLinks : RequiresFeature[*];
    metadata def <requiresFeature> RequiresFeatureMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = requiresFeatureLinks meta SysML::Usage;
    }

    connection def ExcludesFeature :> MemoRelationship {
        doc /* The two features cannot be selected together. Symmetric: either end may be written first. */
        end firstFeature : ProductFeature :>> source;
        end secondFeature : ProductFeature :>> target;
    }
    abstract connection excludesFeatureLinks : ExcludesFeature[*];
    metadata def <excludesFeature> ExcludesFeatureMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = excludesFeatureLinks meta SysML::Usage;
    }

    // Typed dependencies (memo_core_relationships::MemoTypedDependency): the variant
    // is nested in its variation, so it is a dependency's client by qualified name.
    metadata def RealizesFeature :> MemoTypedDependency {
        doc /* `#RealizesFeature dependency from <variant> to <feature>;` The variant exists to give the family this feature. */
    }
    metadata def SelectsFeature :> MemoTypedDependency {
        doc /* `#SelectsFeature dependency from <release> to <feature>, <feature>;` The release contains the variants that realize these features. */
    }
    metadata def ShowsView :> MemoTypedDependency {
        doc /* `#ShowsView dependency from <feature> to <view>, <view>;` The views the feature's viewpoint lists: chosen for what the feature demonstrates, not found by a rule. */
    }
}