memo_architecture_operational_use_cases

SysML API

Public namespace	memo::architecture::operational::use_cases
Declared package	memo_architecture_operational_use_cases
Source	src/architecture/operational/use_cases/memo_use_cases.sysml

Namespace hierarchy

memo → memo::architecture → memo::architecture::operational → memo::architecture::operational::use_cases

Packages

Package
memo_architecture_operational_use_cases

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::*
private	memo_architecture_operational_context_use_context::*
private	memo_assurance_requirements_needs::*

Declarations

Name	SysML kind	Description	Specializes
UseCaseKind	enum def	Controlled values for use case: clinical, service, manufacturing, development.	—
UseCase	use case def	Use case definition specializing MemoUseCase.	MemoUseCase
Motivates	connection def	Typed relationship from Need to UseCase.	MemoRelationship

UseCaseKind

enum def UseCaseKind

Property	Value
Description	Controlled values for use case: clinical, service, manufacturing, development.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_architecture_operational_use_cases

UseCase

use case def UseCase :> MemoUseCase, UseCases::UseCase

Property	Value
Description	Use case definition specializing MemoUseCase.
Kind	use case def
Abstract	No
Specializes	MemoUseCase
Owning package	memo_architecture_operational_use_cases

Motivates

connection def Motivates :> MemoRelationship

Property	Value
Description	Typed relationship from Need to UseCase.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_architecture_operational_use_cases

Source

architecture/operational/use_cases/memo_use_cases.sysml

// Use cases (§5). A UseCase is a goal a person or organization wants to
// achieve with system support — there is no separate Goal class. Clinical,
// service, manufacturing, and development use cases specialize the same base.
package memo_architecture_operational_use_cases {
    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::*;
    private import memo_architecture_operational_context_use_context::*;
    private import memo_assurance_requirements_needs::*;

    enum def UseCaseKind {
        enum clinical;
        enum service;
        enum manufacturing;
        enum development;
    }

    // Specializes the STANDARD library use case as well as MEMO's base. Before
    // this it specialized only `MemoUseCase` and so shadowed `UseCases::UseCase`
    // — same name, same metaclass, none of the semantics — which is why the
    // subject/actor features below had to be re-declared by hand instead of
    // being inherited. The wrapper survives only to carry the display label and
    // lifecycle status; identity comes from `@MemoIdentity`.
    use case def UseCase :> MemoUseCase, UseCases::UseCase {
        // Text of this use case's goal; this is not a separate Goal element.
        attribute goalStatement : String;
        attribute trigger : String;
        attribute preCondition : String;
        attribute successOutcome : String;
        attribute failureOutcome : String;
        attribute postCondition : String;
        // clinical / service / manufacturing / development
        attribute useCaseKind : UseCaseKind;

        // The device or system under consideration supports the goal. Native
        // `subject`, not `ref` (R10-S6): a use case needs an explicit subject
        // before it can declare `actor` (the subject parameter comes first),
        // and "the device/system under consideration"
        // is exactly what a case's subject means, so this was a duplicate
        // waiting to surface once `actor` needed a subject to attach to.
        subject supportingSystem : MemoPart[0..1];
        ref useContext : UseContext[0..1];
        // Who takes part is native `actor` (`actor <role> = <participant>;`),
        // inherited from `UseCases::UseCase`. `primaryUser` and
        // `supportingActors` refs stood here as a second way of saying the
        // same thing and were removed; which actor initiates is carried by
        // the actor's name, as the note on `Initiates` below says.
    }

    connection def Motivates :> MemoRelationship {
        end motivatingNeed : Need :>> source;
        end motivatedUseCase : UseCase :>> target;
    }
    abstract connection motivatesLinks : Motivates[*];
    metadata def <motivates> MotivatesMetadata :> SemanticMetadata {
        :> annotatedElement : SysML::ConnectionDefinition;
        :> annotatedElement : SysML::ConnectionUsage;
        :>> baseType = motivatesLinks meta SysML::Usage;
    }
    // `Initiates` and `ParticipatesIn` are native `actor` (R10-S6): both were
    // a bare typed edge onto UseCase with no attributes of their own, and
    // native `actor` does not distinguish an initiating actor from a
    // participating one — that distinction now lives in how the actor is
    // named on the use case, not in a relationship type. Write
    // `actor <role> = <existingElement>;` inside the use case instead.
    // UML use-case decomposition (`Includes`) is native `include use case` /
    // `include` (R10-S6); write that instead of a connection here. SysML v2
    // has no use-case `extend` (the textual BNF defines IncludeUseCaseUsage
    // and nothing for extend), and MEMO does not add one: an optional path
    // through a use case is an alternate scenario, not a second use case.
}