memo_architecture_implementation_software_structure¶

SysML API


Public namespace	`memo::architecture::implementation::software::structure`
Declared package	`memo_architecture_implementation_software_structure`
Source	`src/architecture/implementation/software/structure/memo_software_structure.sysml`

Namespace hierarchy¶

memo → memo::architecture → memo::architecture::implementation → memo::architecture::implementation::software → memo::architecture::implementation::software::structure

Packages¶

Package
`memo_architecture_implementation_software_structure`

Imports¶

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

Declarations¶

Name	SysML kind	Description	Specializes
`SoftwareElement`	`part def`	Software element definition specializing `MemoPart`.	`MemoPart`
`SoftwareSystem`	`part def`	Software system definition specializing `SoftwareElement`.	`SoftwareElement`
`ModuleKind`	`enum def`	Module-view element (design responsibility). Runtime properties (period, WCET, scheduling) moved to SoftwareComponent. item / unit / package / library / code / firmware / soup (IEC 62304).	—
`SoftwareModule`	`part def`	Software module definition specializing `SoftwareElement`.	`SoftwareElement`
`Algorithm`	`part def`	Algorithm definition specializing `MemoPart`.	`MemoPart`
`DataModel`	`part def`	Data model definition specializing `MemoPart`.	`MemoPart`
`ConfigurationArtifact`	`part def`	Configuration artifact definition specializing `MemoPart`.	`MemoPart`
`SoftwareItem`	`item def`	Software data/content that may be stored or exchanged through ports.	`MemoItem`
`SBOMEntry`	`item def`	Sbomentry definition specializing `SoftwareItem`.	`SoftwareItem`
`DependsOnSoup`	`connection def`	Moved out of memo_core_relationships: their ends are typed against types declared here, and core must not depend on a domain package.	`MemoRelationship`

SoftwareElement¶

abstract part def SoftwareElement specializes MemoPart

Property	Value
Description	Software element definition specializing `MemoPart`.
Kind	`part def`
Abstract	Yes
Specializes	`MemoPart`
Owning package	`memo_architecture_implementation_software_structure`

SoftwareSystem¶

part def SoftwareSystem specializes SoftwareElement

Property	Value
Description	Software system definition specializing `SoftwareElement`.
Kind	`part def`
Abstract	No
Specializes	`SoftwareElement`
Owning package	`memo_architecture_implementation_software_structure`

ModuleKind¶

enum def ModuleKind

Property	Value
Description	Module-view element (design responsibility). Runtime properties (period, WCET, scheduling) moved to SoftwareComponent. item / unit / package / library / code / firmware / soup (IEC 62304).
Kind	`enum def`
Abstract	No
Specializes	—
Owning package	`memo_architecture_implementation_software_structure`

SoftwareModule¶

part def SoftwareModule specializes SoftwareElement

Property	Value
Description	Software module definition specializing `SoftwareElement`.
Kind	`part def`
Abstract	No
Specializes	`SoftwareElement`
Owning package	`memo_architecture_implementation_software_structure`

Algorithm¶

part def Algorithm specializes MemoPart

Property	Value
Description	Algorithm definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_implementation_software_structure`

DataModel¶

part def DataModel specializes MemoPart

Property	Value
Description	Data model definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_implementation_software_structure`

ConfigurationArtifact¶

part def ConfigurationArtifact specializes MemoPart

Property	Value
Description	Configuration artifact definition specializing `MemoPart`.
Kind	`part def`
Abstract	No
Specializes	`MemoPart`
Owning package	`memo_architecture_implementation_software_structure`

SoftwareItem¶

abstract item def SoftwareItem specializes MemoItem

Property	Value
Description	Software data/content that may be stored or exchanged through ports.
Kind	`item def`
Abstract	Yes
Specializes	`MemoItem`
Owning package	`memo_architecture_implementation_software_structure`

SBOMEntry¶

item def SBOMEntry specializes SoftwareItem

Property	Value
Description	Sbomentry definition specializing `SoftwareItem`.
Kind	`item def`
Abstract	No
Specializes	`SoftwareItem`
Owning package	`memo_architecture_implementation_software_structure`

DependsOnSoup¶

connection def DependsOnSoup :> MemoRelationship

Property	Value
Description	Moved out of memo_core_relationships: their ends are typed against types declared here, and core must not depend on a domain package.
Kind	`connection def`
Abstract	No
Specializes	`MemoRelationship`
Owning package	`memo_architecture_implementation_software_structure`

Source¶

architecture/implementation/software/structure/memo_software_structure.sysml

// Software module view (§11; IEC 62304 5.3-5.4). Following the SEI Views and
// Beyond viewtypes, modules are implementation/code units; interacting runtime
// elements are SoftwareComponents in
// memo_architecture_implementation_software_runtime, and allocation lives in
// memo_architecture_realization_deployment.
package memo_architecture_implementation_software_structure {
    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_logical_structure::*;

    // IEC 62304 §3.25: a SOFTWARE ITEM is "any identifiable part of a computer
    // program". It is the general, recursive term — a SOFTWARE SYSTEM (§3.24)
    // is the top item and a SOFTWARE UNIT (§3.26) is one not subdivided
    // further; both are software items. So this is a base, not a fourth
    // sibling of system/module/component.
    //
    // It exists because §4.3 classifies, and §5.3–5.4 decompose, SOFTWARE
    // ITEMS — not "modules" or "components" specifically. Anything the
    // standard obliges at item level therefore belongs here, and every
    // software view inherits it rather than re-declaring it: the code view
    // (SoftwareModule), the runtime view (SoftwareComponent), the system, and
    // the user interface (memo_architecture_implementation_ui::UIElement).
    // Structural software decomposition is part-native. IEC 62304 also uses
    // the term "software item" for this concept, but reserving SoftwareItem
    // for the native SysML item family keeps structural parts and exchanged
    // values unambiguous in the model.
    abstract part def SoftwareElement specializes MemoPart {
        attribute safetyClass : SafetyClassKind;
        attribute complexity : ComplexityKind;
    }

    part def SoftwareSystem specializes SoftwareElement {
        attribute version : String;
        attribute operatingSystem : String;
    }

    // Module-view element (design responsibility). Runtime properties
    // (period, WCET, scheduling) moved to SoftwareComponent.
    // item / unit / package / library / code / firmware / soup (IEC 62304).
    enum def ModuleKind {
        enum 'item';
        enum unit;
        enum 'package';
        enum 'library';
        enum code;
        enum firmware;
        enum soup;
    }

    part def SoftwareModule specializes SoftwareElement {
        attribute moduleKind : ModuleKind;
        attribute responsibility : String;
        // module-kind-specific detail (set only for the relevant moduleKind)
        attribute iec62304Role : String[0..1];
        attribute implementationLanguage : String[0..1];
        attribute namespacePath : String[0..1];
        attribute libraryVersion : String[0..1];
        attribute internallyDeveloped : Boolean[0..1];
        attribute firmwareTarget : String[0..1];
        attribute updateMechanism : String[0..1];
        // SOUP (IEC 62304 §8) — set only when moduleKind = soup
        attribute soupVersion : String[0..1];
        attribute soupVendor : String[0..1];
        attribute knownAnomalies : String[0..1];
        attribute riskAcceptance : String[0..1];
        attribute soupClassification : SOUPClassificationKind[0..1];
    }

    part def Algorithm specializes MemoPart {
        attribute algorithmKind : String;
        attribute inputSummary : String;
        attribute outputSummary : String;
        attribute clinicalPerformanceClaim : String;
    }
    part def DataModel specializes MemoPart {
        attribute schemaReference : String;
        attribute persistenceScope : String;
    }
    part def ConfigurationArtifact specializes MemoPart {
        attribute configurationScope : String;
        attribute version : String;
    }

    // Software data/content that may be stored or exchanged through ports.
    abstract item def SoftwareItem specializes MemoItem {
        attribute schemaIdentifier : String;
        attribute schemaVersion : String;
        attribute encoding : String;
        attribute timestampRequired : Boolean;
    }

    item def SBOMEntry specializes SoftwareItem {
        attribute componentName : String;
        attribute version : String;
        attribute supplier : String;
        attribute license : String;
        attribute hash : String;
    }

    // `ModuleUses` is native `dependency` (R10-S6): write
    // `dependency <usingModule> to <usedModule>;` instead of a connection.

    // ── Relations owned by this package ─────────────────────────────
    // Moved out of memo_core_relationships: their ends are typed against
    // types declared here, and core must not depend on a domain package.
    connection def DependsOnSoup :> MemoRelationship {
        end component : MemoPart :>> source;
        end soupItem : SoftwareElement :>> target;
    }
    abstract connection dependsOnSoupLinks : DependsOnSoup[*];
    metadata def <dependsOnSoup> DependsOnSoupMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = dependsOnSoupLinks meta SysML::Usage;
    }
}