Structure

Generated from the sysml-rs language pack — see the Language Reference index for provenance, licensing, and the raw JSON. 65 cards.

Association

KerML — kerml.structure.association

An association is a classifier of links between things, relating two or more end features. It is the KerML base of SysML connection definitions; its ends name the related types.

package P { class C; assoc A { end a : C; end b : C; } }

Normative clauses: KerML §7.4.5

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Association Structure

KerML — kerml.structure.association-structure

An association structure is both an association and a structure: a link that itself carries structural features, so the link between things is a structured object in its own right.

package P { class C; assoc struct AS { end a : C; end b : C; } }

Normative clauses: KerML §7.4.5.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Binding Connector

KerML — kerml.structure.binding-connector

A binding connector asserts that its two ends are the same thing — a binding that forces the connected features to have identical values. It is written with the equals form.

package P { class C; feature x : C; binding b = x; }

Normative clauses: KerML §8.2.5.5.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Class

KerML — kerml.structure.class

A class is a classifier of occurrences — things that exist over time and space with intrinsic identity. It is the KerML base from which SysML parts and other occurrence-typed constructs derive.

package P { class C; }

Normative clauses: KerML §7.4.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

A classifier is a type that classifies individual things by their intrinsic identity, as opposed to a feature that classifies things by their role. Classes, structures, and behaviors are all classifiers.

package P { classifier C; }

Normative clauses: KerML §7.3.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Classifier Conjugation

KerML — kerml.structure.classifier-conjugation

A classifier conjugation (classifier C ~ D; or ... conjugates D;) declares a classifier as the conjugate of another, inheriting its features with directions reversed. The grammar rule ClassifierConjugation returns Conjugation — the declaring classifier is the conjugatedType, the target the originalType; there is no distinct ClassifierConjugation metaclass.

package P { classifier D; classifier C ~ D; }

Normative clauses: KerML §8.2.4.2.1

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Conjugation

KerML — kerml.structure.conjugation

A conjugation relationship (conjugates or the symbolic ~) makes a type inherit another’s features with input/output directions reversed. Lowers to a distinct Conjugation relationship (conjugatedType = the declaring type, originalType = the target). Both spellings are admitted; in lambda-parameter position only the conjugates keyword applies (the ~ there is the unary operator).

package P { class A; class X conjugates A; }

Normative clauses: KerML §8.3.3.1.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Connector

KerML — kerml.structure.connector

A connector is a feature that links two or more other features, typed by an association. It is the KerML base of SysML connection usages; its ends name the connected features.

package P { class C; feature x : C; feature y : C; connector c from x to y; }

Normative clauses: KerML §7.4.6

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Data Type

KerML — kerml.structure.data-type

A datatype is a classifier of data values — things distinguished only by their value, with no intrinsic identity, so two equal values are the same datum. It is the KerML base of SysML attribute value types.

package P { datatype D; }

Normative clauses: KerML §7.4.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Differencing

KerML — kerml.structure.differencing

A differencing relationship (differences) makes a type the difference of the listed types — the instances of the first that are not in the rest. Lowers to a distinct Differencing relationship owned by the declaring type.

package P { class A; class B; class D differences A, B; }

Normative clauses: KerML §8.3.3.1.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Disjoining

KerML — kerml.structure.disjoining

A disjoining relationship (disjoint from) asserts two types share no instances. Lowers to a distinct Disjoining relationship owned by the declaring type.

package P { class A; class B; class J disjoint from A, B; }

Normative clauses: KerML §8.3.3.1.4

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

EndFeatureMembership

KerML — kerml.structure.end-feature-membership

The EndFeatureMembership metamodel relationship (KerML abstract syntax). It has no dedicated concrete notation — it is how the model graph is wired — so it is documented as a metamodel concept with its inheritance and property constraints, not a grammar card.

Normative clauses: KerML §8.3.3.3.3

Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown

Feature Conjugation

KerML — kerml.structure.feature-conjugation

A feature conjugation (feature b ~ a; or ... conjugates a;) declares a feature as the conjugate of another feature. The grammar rule FeatureConjugation returns Conjugation — the declaring feature is the conjugatedType, the target feature the originalType; there is no distinct FeatureConjugation metaclass.

package P { part def B { attribute a; attribute b ~ a; } }

Normative clauses: KerML §8.2.4.3.1

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Feature Inverting

KerML — kerml.structure.feature-inverting

A feature-inverting relationship (inverse of) asserts two features are inverses — each instance’s value under one is the reverse of the other. Lowers to a distinct FeatureInverting relationship owned by the declaring feature.

package P { feature f; feature g inverse of f; }

Normative clauses: KerML §8.3.3.3.6

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

FeatureMembership

KerML — kerml.structure.feature-membership

The FeatureMembership metamodel relationship (KerML abstract syntax). It has no dedicated concrete notation — it is how the model graph is wired — so it is documented as a metamodel concept with its inheritance and property constraints, not a grammar card.

Normative clauses: KerML §8.3.3.1.6

Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown

Feature Typing

KerML — kerml.structure.feature-typing

A feature typing relates a feature to a type that classifies it — the relationship behind x : T. The same abstract-syntax relationship is realized by two divergent concrete syntaxes: KerML’s 'typing' typedFeature (':'|'typed' 'by') FeatureType versus SysML’s OwnedFeatureTyping | ConjugatedPortTyping dispatcher.

package P { part def A; part a : A; }

Normative clauses: KerML §8.3.3.3.7

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Related: Feature Typing

Filter Package

KerML — kerml.structure.filter-package

A filter package restricts which members are imported by a filter condition, written filter @Metadata inside the package. The condition lowers to a distinct ElementFilterMembership.

metadata def Safety; package P { filter @Safety; }

Normative clauses: KerML §8.3.4.13.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Import

KerML — kerml.structure.import

An import brings the members of another namespace into scope so their names resolve without full qualification. Visibility controls whether the imported names are re-exported.

package Lib { part def Widget; }
package App { import Lib::*; part w : Widget; }

Normative clauses: KerML §8.3.2.4.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Intersecting

KerML — kerml.structure.intersecting

An intersecting relationship (intersects) makes a type the intersection of the listed types — its instances are those common to all intersected types. Lowers to a distinct Intersecting relationship owned by the declaring type.

package P { class A; class B; class I2 intersects A, B; }

Normative clauses: KerML §8.3.3.1.7

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Library Package

KerML — kerml.structure.library-package

A library package is a package marked as a reusable model library with the library keyword. Its members are standard/shared definitions imported by other models; it lowers to a distinct LibraryPackage element.

library package Lib { part def P; }

Normative clauses: KerML §8.3.4.13.3

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Membership

KerML — kerml.structure.membership

The Membership metamodel relationship (KerML abstract syntax). It has no dedicated concrete notation — it is how the model graph is wired — so it is documented as a metamodel concept with its inheritance and property constraints, not a grammar card.

Normative clauses: KerML §8.3.2.4.3

Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown

Membership Import

KerML — kerml.structure.membership-import

A membership import brings one named member of a namespace into scope, written import Path::member. It lowers to a distinct MembershipImport, in contrast to the wildcard namespace import.

package Q { part def X; } package R { import Q::X; }

Normative clauses: KerML §8.3.2.4.4

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Metaclass

KerML — kerml.structure.metaclass

A metaclass is a class whose instances are themselves model elements — the type of a metadata annotation. Metadata features are typed by metaclasses to attach structured data to the elements they annotate.

package P { metaclass M; }

Normative clauses: KerML §8.4.4.13.1

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Multiplicity

KerML — kerml.structure.multiplicity

A multiplicity bounds how many instances a feature may have, written as a range in square brackets. Bounds are a lower and an optional upper limit.

package P { part def A { attribute a[0..1]; } }

Normative clauses: KerML §8.3.3.1.9

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Namespace

KerML — kerml.structure.namespace

A namespace owns named members and defines the scope in which those names are visible and resolvable. Packages are the usual concrete namespaces a modeller writes; membership establishes the owned names.

package Ns { part def A; part def B; }

Normative clauses: KerML §8.3.2.4.5

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Namespace Import

KerML — kerml.structure.namespace-import

A namespace import brings every member of a namespace into scope, written import Path::*. It lowers to a distinct NamespaceImport and is the wildcard companion of the single-member membership import.

package Q { part def X; } package R { import Q::*; }

Normative clauses: KerML §8.3.2.4.6

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

OwningMembership

KerML — kerml.structure.owning-membership

The OwningMembership metamodel relationship (KerML abstract syntax). It has no dedicated concrete notation — it is how the model graph is wired — so it is documented as a metamodel concept with its inheritance and property constraints, not a grammar card.

Normative clauses: KerML §8.3.2.4.8

Support (sysml-rs): parse unknown · resolve unknown · elaborate unknown · execute unknown

Package

KerML — kerml.structure.package

A package is the concrete namespace a modeller writes to group related members and control their visibility. It owns named members and defines the scope in which those names resolve; membership within a package must be name-unique.

package P { class C; package Inner { class D; } }

Normative clauses: KerML §7.4.14

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Redefinition

KerML — kerml.structure.redefinition

A redefinition relates a feature to an inherited feature it replaces, so the redefining feature stands in for the original in its context — the redefines (or :>>) relationship. It is a specialized subsetting that also hides the redefined feature.

package P { type A; feature f : A; feature h : A redefines f; }

Normative clauses: KerML §8.3.3.3.8

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Specialization

KerML — kerml.structure.specialization

A specialization relates a more specific type to a more general one, so the specific type inherits the general type’s features. In usage syntax it is written with the subclassification operator.

package P { part def A; part def B :> A; }

Normative clauses: KerML §8.3.3.1.8

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Structure

KerML — kerml.structure.structure

A structure is a class whose instances are structural — composed of interconnected parts rather than behavioral occurrences. It is the KerML base from which SysML part definitions derive.

package P { struct S; }

Normative clauses: KerML §7.4.4

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Subsetting

KerML — kerml.structure.subsetting

A subsetting relates a feature to a more general feature whose values include all of the subsetting feature’s values — the subsets (or :>) relationship between features. It is the feature-level analogue of subclassification.

package P { type A; feature f : A; feature g : A subsets f; }

Normative clauses: KerML §8.3.3.3.10

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Type

KerML — kerml.structure.type

A type is the most general KerML classifier of things: it classifies a set of instances and may specialize other types, inheriting their features. Classes, datatypes, associations, and behaviors are all specialized kinds of type.

package P { type T; }

Normative clauses: KerML §7.3.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Type Featuring

KerML — kerml.structure.type-featuring

A type-featuring relationship (featured by) makes a feature a feature of another type. Lowers to a distinct TypeFeaturing relationship owned by the declaring feature.

package P { class A; feature g featured by A; }

Normative clauses: KerML §8.3.3.3.11

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Unioning

KerML — kerml.structure.unioning

A unioning relationship (unions) makes a type the union of the listed types — its instances are those of any unioned type. Lowers to a distinct Unioning relationship owned by the declaring type.

package P { class A; class B; class U unions A, B; }

Normative clauses: KerML §8.3.3.1.11

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Allocation Definition

SysML — sysml.structure.allocation-definition

An allocation definition, written allocation def, defines a reusable kind of allocation relating a source element to a target element. It lowers to a distinct AllocationDefinition.

allocation def AD { }

Normative clauses: SysML §7.15.2

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Allocation Usage

SysML — sysml.structure.allocation-usage

An allocation usage records that one element is allocated to another — a mapping decision (for example a function to a component) pending refinement into a firmer relationship. It has two or more ends and is typed by an allocation definition.

package P { part def Sys { part a; part b; allocation al allocate a to b; } }

Normative clauses: SysML §8.3.15.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Attribute Definition

SysML — sysml.structure.attribute-definition

An attribute definition defines a kind of value-typed feature that carries data rather than identity. Usages typed by it hold quantities or literals.

package P { attribute def Temperature; attribute t : Temperature; }

Normative clauses: SysML §8.3.7.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Attribute Usage

SysML — sysml.structure.attribute-usage

An attribute usage is a value-typed feature carrying data — a quantity or literal — rather than identity. It is typed by an attribute definition or a value type.

package P { attribute def Temperature; attribute t : Temperature; }

Normative clauses: SysML §8.3.7.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Binding Connector (as Usage)

SysML — sysml.structure.binding-connector-as-usage

A binding connector as usage, written bind a = b, asserts that two features have the same value at all times. It lowers to a distinct BindingConnectorAsUsage — the SysML usage form of a KerML binding connector.

part def P { attribute a; attribute b; bind a = b; }

Normative clauses: SysML §8.3.13.2

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Conjugated Port Definition

SysML — sysml.structure.conjugated-port-definition

A conjugated port definition is the input/output-reversed counterpart of a port definition, referenced with the ~ prefix (port p : ~P). It lowers to a distinct ConjugatedPortDefinition whose directions are flipped from the base port.

port def Pt { out item a; } part def Q { port p : ~Pt; }

Normative clauses: SysML §7.12.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Connection Definition

SysML — sysml.structure.connection-definition

A connection definition defines a reusable kind of connection between parts, with two or more ends. Connection usages instantiate it to wire specific parts together.

package P { connection def Link; }

Normative clauses: SysML §8.3.13.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Connection Usage

SysML — sysml.structure.connection-usage

A connection usage wires two or more parts together through connector ends. It is owned by a containing type (a part or action), not directly by a package, and instantiates a connection definition or the base association.

package P { part def Sys { part a; part b; connection c connect a to b; } }

Normative clauses: SysML §8.3.13.4

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Dependency

SysML — sysml.structure.dependency

A dependency declares that one or more client elements depend on one or more supplier elements — a coarse traceability link. It is a cross-grammar concept declared identically in KerML and SysML.

package P { part def A; part def B; dependency A to B; }

Normative clauses: SysML §7.3.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Enumerated Value

SysML — sysml.structure.enumerated-value

An enumerated value is the member form inside an enumeration definition. The spec models it as an EnumerationUsage (the grammar rule EnumeratedValue returns EnumerationUsage), so both the bare-name value form and the enum <name> form lower to an EnumerationUsage via a VariantMembership — there is no distinct EnumeratedValue metaclass.

package P { enum def Priority { high; low; } }

Normative clauses: SysML §7.8.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Enumeration Definition

SysML — sysml.structure.enumeration-definition

An enumeration definition defines a closed set of named literal values. Each enumerated value is a singleton usage of the definition, and a typed usage may take only one of them.

package P { enum def Color { enum red; enum green; } }

Normative clauses: SysML §8.3.8.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Enumeration Usage

SysML — sysml.structure.enumeration-usage

An enumeration usage is an attribute usage whose type is an enumeration definition. Inside an enum def body, enum <name>; declares an enumerated value (owned through a VariantMembership); standalone, enum <name> : <EnumDef>; declares an ordinary usage typed by the enumeration (plain owned member — the VariantMembership wrapper is enum-def-body-only). Both lower to a distinct EnumerationUsage.

package P { enum def Color { enum red; enum green; } }

Normative clauses: SysML §8.3.8.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Event Occurrence Usage

SysML — sysml.structure.event-occurrence-usage

An event occurrence usage marks a point event within an enclosing occurrence’s life — the happening of an occurrence, rather than the occurrence itself. It is written with the event keyword and either references an existing occurrence or declares one inline.

package P { occurrence def O { event occurrence e; } }

Normative clauses: SysML §8.3.9.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Feature Typing

SysML — sysml.structure.feature-typing

package P { part def A; part a : A; }

Normative clauses: KerML §8.3.3.3.7

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Related: Feature Typing

Flow Connection

SysML — sysml.structure.flow-connection

A flow connection transfers items from a source port or feature to a compatible target across a connection. Endpoints must be reachable and their item types compatible.

package P { part def A { out port o; } part def B { in port i; } part def Sys { part a : A; part b : B; flow a.o to b.i; } }

Normative clauses: SysML §8.3.16.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Flow Definition

SysML — sysml.structure.flow-definition

A flow definition, written flow def, defines a reusable kind of transfer of items between features. It lowers to a distinct FlowDefinition that flow usages can be typed by.

flow def FD { }

Normative clauses: SysML §8.3.16.2

Support (sysml-rs): parse ✓ · resolve unknown · elaborate unknown · execute unknown

Individual Definition

SysML — sysml.structure.individual-definition

An individual definition (individual def X;) defines a class constrained to represent at most one individual over its lifetime. The grammar rule IndividualDefinition returns OccurrenceDefinition with isIndividual = true — there is no distinct IndividualDefinition metaclass. It lowers to an OccurrenceDefinition carrying the flag (the spec’s owned empty-multiplicity member is consciously carried by the flag alone).

package P { individual def X; abstract individual def Y :> X; }

Normative clauses: SysML §7.9.4

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Individual Usage

SysML — sysml.structure.individual-usage

An individual usage (the individual prefix) names a single identified occurrence. The spec models it as an OccurrenceUsage with isIndividual = true; it lowers to an OccurrenceUsage carrying that flag — there is no distinct IndividualUsage metaclass.

package P { occurrence def D; individual d : D; }

Normative clauses: SysML §7.9.4

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Interface Definition

SysML — sysml.structure.interface-definition

An interface definition defines a reusable kind of connection between ports, coupling their directed features. Interface usages instantiate it between specific ports.

package P { interface def Ifc; }

Normative clauses: SysML §8.3.14.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Interface Usage

SysML — sysml.structure.interface-usage

An interface usage connects two ports through interface ends, coupling their directed features. Like a connection it must be owned by a containing type, not directly by a package, and instantiates an interface definition.

package P { port def Sig; part def Sys { part x { port p1 : Sig; } part y { port p2 : Sig; } interface i connect x.p1 to y.p2; } }

Normative clauses: SysML §8.3.14.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Item Definition

SysML — sysml.structure.item-definition

An item definition defines a kind of thing that can be created, stored, or moved through a system — items carry identity but need not be behavioral parts. Usages typed by it occupy structure or flow along connections.

package P { item def Widget; }

Normative clauses: SysML §8.3.10.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Item Usage

SysML — sysml.structure.item-usage

An item usage is a typed occurrence of an item within a structure or flow. It is typed by an item definition and may be nested in a part or carried by a flow connection.

package P { item def Widget; item w : Widget; }

Normative clauses: SysML §8.3.10.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Occurrence Definition

SysML — sysml.structure.occurrence-definition

An occurrence definition defines a kind of thing that exists over time and space — the common base of parts (structure) and actions (behavior).

package P { occurrence def Event; }

Normative clauses: SysML §8.3.9.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Occurrence Usage

SysML — sysml.structure.occurrence-usage

An occurrence usage is a typed occurrence within a model’s space-time. It is typed by an occurrence definition and may be portioned in time or space.

package P { occurrence def Event; occurrence e : Event; }

Normative clauses: SysML §8.3.9.4

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Part Definition

SysML — sysml.structure.part-definition

A part definition defines a reusable kind of system component with structure and behavior. Part usages instantiate it within a containing structure.

package P { part def Engine; }

Normative clauses: SysML §8.3.11.2

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Part Usage

SysML — sysml.structure.part-usage

A part usage is a typed occurrence of a part within a containing structure. It is typed by a part definition and may nest further usages or redefine inherited ones.

package P { part def Engine; part e : Engine; }

Normative clauses: SysML §8.3.11.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Port Definition

SysML — sysml.structure.port-definition

A port definition defines a reusable kind of interaction point through which items and information pass. Port usages instantiate it on parts, optionally conjugated to reverse direction.

package P { port def Fuel; }

Normative clauses: SysML §8.3.12.5

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Port Usage

SysML — sysml.structure.port-usage

A port usage is a typed interaction point on a part through which items and information pass. It is typed by a port definition and may be conjugated to reverse direction.

package P { port def Fuel; part def E { port p : Fuel; } }

Normative clauses: SysML §8.3.12.6

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Portion Usage

SysML — sysml.structure.portion-usage

A portion usage (snapshot or timeslice) denotes a temporal portion of an occurrence. The spec models it as an OccurrenceUsage carrying a PortionKind; it lowers to an OccurrenceUsage with that portion kind — there is no distinct PortionUsage metaclass.

package P { occurrence def D; occurrence o : D { snapshot s; } }

Normative clauses: SysML §8.3.9.5

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Reference Usage

SysML — sysml.structure.reference-usage

A reference usage is a non-composite feature that refers to something owned elsewhere, rather than composing it. The ref keyword marks a feature as referential.

package P { part def W { ref r; } }

Normative clauses: SysML §8.3.6.3

Support (sysml-rs): parse ✓ · resolve ✓ · elaborate unknown · execute unknown

Keyboard shortcuts

The SysML v2 Book