memo_architecture_operational_context_stakeholders

SysML API

Public namespace	memo::architecture::operational::context::stakeholders
Declared package	memo_architecture_operational_context_stakeholders
Source	src/architecture/operational/context/stakeholders/memo_stakeholders.sysml

Namespace hierarchy

memo → memo::architecture → memo::architecture::operational → memo::architecture::operational::context → memo::architecture::operational::context::stakeholders

Packages

Package
memo_architecture_operational_context_stakeholders

Imports

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

Declarations

Name	SysML kind	Description	Specializes
ArchitectureDescription	part def	Architecture description definition specializing MemoPart.	MemoPart
ModelKind	part def	Model definition specializing MemoPart.	MemoPart
CorrespondenceRule	part def	42010 correspondence: a rule that must hold between architecture description elements (e.g. consistency between two views).	MemoPart
GovernKind	enum def	Controlled values for govern: correspondence.	—
Governs	connection def	Typed relationship for governs.	MemoRelationship

ArchitectureDescription

part def ArchitectureDescription specializes MemoPart

Property	Value
Description	Architecture description definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_architecture_operational_context_stakeholders

ModelKind

part def ModelKind specializes MemoPart

Property	Value
Description	Model definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_architecture_operational_context_stakeholders

CorrespondenceRule

part def CorrespondenceRule specializes MemoPart

Property	Value
Description	42010 correspondence: a rule that must hold between architecture description elements (e.g. consistency between two views).
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_architecture_operational_context_stakeholders

GovernKind

enum def GovernKind

Property	Value
Description	Controlled values for govern: correspondence.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_architecture_operational_context_stakeholders

Governs

connection def Governs :> MemoRelationship

Property	Value
Description	Typed relationship for governs.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_operational_context_stakeholders

Source

architecture/operational/context/stakeholders/memo_stakeholders.sysml

// ISO/IEC/IEEE 42010 architecture-description core (§4): ArchitectureDescription,
// ModelKind, and CorrespondenceRule below. Stakeholders and concerns — 42010's
// other cornerstones — are native SysML v2 constructs (stakeholder memberships
// and `concern def`), used directly rather than reinvented as MEMO types. A
// View (memo_viewpoints_definitions::MemoView) conforms to a Viewpoint within
// an ArchitectureDescription.
package memo_architecture_operational_context_stakeholders {
    private import Metaobjects::SemanticMetadata;
    private import ScalarValues::*;

    private import memo_core_common::*;
    private import memo_core_enumerations::*;
    private import memo_core_relationships::*;
    private import memo_architecture_operational_context_actors::*;
    part def ArchitectureDescription specializes MemoPart {
        attribute systemOfInterest : String;
        attribute version : String;
    }

    part def ModelKind specializes MemoPart {
        attribute conventions : String;
        attribute notationReference : String;
    }

    // 42010 correspondence: a rule that must hold between architecture
    // description elements (e.g. consistency between two views).
    part def CorrespondenceRule specializes MemoPart {
        attribute ruleExpression : String;
    }

    // Governs unifies GovernsCorrespondence / GovernsUse, keyed by governKind.
    enum def GovernKind {
        enum correspondence;
        enum 'use';
    }
    connection def Governs :> MemoRelationship {
        attribute governKind : GovernKind;
        end governor : MemoPart :>> source;
        end governedElement : MemoPart :>> target;
    }
    abstract connection governsLinks : Governs[*];
    metadata def <governs> GovernsMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = governsLinks meta SysML::Usage;
    }
}