sysml
type: Ontology
imports: Ecore

AcceptActionUsage
type: Class
comment: An AcceptActionUsage is an ActionUsage that specifies the acceptance of an incomingTransfer from the Occurrence given by the result of its receiverArgument Expression. (If no receiverArgument is provided, the default is the this context of the AcceptActionUsage.) The payload of the accepted Transfer is output on its payloadParameter. Which Transfers may be accepted is determined by conformance to the typing and (potentially) binding of the payloadParameter. inputParameters()->size() >= 2 receiverArgument = argument(2) payloadArgument = argument(1) payloadParameter = if parameter->isEmpty() then null else parameter->first() endif not isTriggerAction() implies specializesFromLibrary('Actions::acceptActions') isSubactionUsage() and not isTriggerAction() implies specializesFromLibrary('Actions::Action::acceptSubactions') isTriggerAction() implies specializesFromLibrary('Actions::TransitionAction::accepter') payloadArgument <> null and payloadArgument.oclIsKindOf(TriggerInvocationExpression) implies let invocation : Expression = payloadArgument.oclAsType(Expression) in parameter->size() >= 2 and invocation.parameter->size() >= 2 and ownedFeature->selectByKind(BindingConnector)->exists(b | b.relatedFeatures->includes(parameter->at(2)) and b.relatedFeatures->includes(invocation.parameter->at(2)))
subclass of: Restriction
  cardinality: 1
  on property: payloadParameter
subclass of: ActionUsage

payloadArgument
type: FunctionalProperty
type: ObjectProperty
comment: An Expression whose result is bound to the payload parameter of this AcceptActionUsage. If provided, the AcceptActionUsage will only accept a Transfer with exactly this payload.
domain: AcceptActionUsage
range: Expression

payloadParameter
type: FunctionalProperty
type: ObjectProperty
comment: The nestedReference of this AcceptActionUsage that redefines the payload output parameter of the base AcceptActionUsage AcceptAction from the Systems Model Library.
domain: AcceptActionUsage
range: ReferenceUsage
sub property of: parameter
sub property of: nestedReference

receiverArgument
type: FunctionalProperty
type: ObjectProperty
comment: An Expression whose result is bound to the receiver input parameter of this AcceptActionUsage.
domain: AcceptActionUsage
range: Expression

ActionDefinition
type: Class
comment: An ActionDefinition is a Definition that is also a Behavior that defines an Action performed by a system or part of a system. specializesFromLibrary('Actions::Action') action = usage->selectByKind(ActionUsage)
subclass of: Behavior
subclass of: OccurrenceDefinition

action
is ordered: true
type: ObjectProperty
comment: The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition.
domain: ActionDefinition
range: ActionUsage
sub property of: step
sub property of: usage

ActionUsage
type: Class
comment: An ActionUsage is a Usage that is also a Step, and, so, is typed by a Behavior. Nominally, if the type is an ActionDefinition, an ActionUsage is a Usage of that ActionDefinition within a system. However, other kinds of kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries. isSubactionUsage() implies specializesFromLibrary('Actions::Action::subactions') specializesFromLibrary('Actions::actions') isComposite and owningType <> null and (owningType.oclIsKindOf(PartDefinition) or owningType.oclIsKindOf(PartUsage)) implies specializesFromLibrary('Parts::Part::ownedActions') owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(StateSubactionMembership) implies let kind : StateSubactionKind = owningFeatureMembership.oclAsType(StateSubactionMembership).kind in if kind = StateSubactionKind::entry then redefinesFromLibrary('States::StateAction::entryAction') else if kind = StateSubactionKind::do then redefinesFromLibrary('States::StateAction::doAction') else redefinesFromLibrary('States::StateAction::exitAction') endif endif
subclass of: OccurrenceUsage
subclass of: Step

actionDefinition
is ordered: true
type: ObjectProperty
comment: The Behaviors that are the types of this ActionUsage. Nominally, these would be ActionDefinitions, but other kinds of Kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries.
domain: ActionUsage
range: Behavior
sub property of: occurrenceDefinition
sub property of: behavior

ActorMembership
type: Class
comment: An ActorMembership is a ParameterMembership that identifies a PartUsage as an actor parameter, which specifies a role played by an external entity in interaction with the owningType of the ActorMembership. owningType.oclIsKindOf(RequirementUsage) or owningType.oclIsKindOf(RequirementDefinition) or owningType.oclIsKindOf(CaseDefinition) or owningType.oclIsKindOf(CaseUsage)
subclass of: Restriction
  cardinality: 1
  on property: ownedActorParameter
subclass of: ParameterMembership

ownedActorParameter
type: FunctionalProperty
type: ObjectProperty
comment: The PartUsage specifying the actor.
domain: ActorMembership
range: PartUsage
sub property of: ownedMemberParameter

AllocationDefinition
type: Class
comment: An AllocationDefinition is a ConnectionDefinition that specifies that some or all of the responsibility to realize the intent of the source is allocated to the target instances. Such allocations define mappings across the various structures and hierarchies of a system model, perhaps as a precursor to more rigorous specifications and implementations. An AllocationDefinition can itself be refined using nested allocations that give a finer-grained decomposition of the containing allocation mapping. allocation = usage->selectAsKind(AllocationUsage) specializesFromLibrary('Allocations::Allocation')
subclass of: ConnectionDefinition

allocation
is ordered: true
type: ObjectProperty
comment: The AllocationUsages that refine the allocation mapping defined by this AllocationDefinition.
domain: AllocationDefinition
range: AllocationUsage
sub property of: usage

AllocationUsage
type: Class
comment: An AllocationUsage is a usage of an AllocationDefinition asserting the allocation of the source feature to the target feature. specializesFromLibrary('Allocations::allocations')
subclass of: ConnectionUsage

allocationDefinition
is ordered: true
type: ObjectProperty
comment: The AllocationDefinitions that are the types of this AllocationUsage.
domain: AllocationUsage
range: AllocationDefinition
sub property of: connectionDefinition

AnalysisCaseDefinition
type: Class
comment: An AnalysisCaseDefinition is a CaseDefinition for the case of carrying out an analysis. resultExpression = let results : OrderedSet(ResultExpressionMembership) = featureMembersip-> selectByKind(ResultExpressionMembership) in if results->isEmpty() then null else results->first().ownedResultExpression endif specializesFromLibrary('AnalysisCases::AnalysisCase')
subclass of: CaseDefinition

resultExpression
type: FunctionalProperty
type: ObjectProperty
comment: An Expression used to compute the result of the AnalysisCaseDefinition, owned via a ResultExpressionMembership.
domain: AnalysisCaseDefinition
range: Expression
sub property of: expression
sub property of: ownedFeature

AnalysisCaseUsage
type: Class
comment: An AnalysisCaseUsage is a Usage of an AnalysisCaseDefinition. resultExpression = let results : OrderedSet(ResultExpressionMembership) = featureMembersip-> selectByKind(ResultExpressionMembership) in if results->isEmpty() then null else results->first().ownedResultExpression endif specializesFromLibrary('AnalysisCases::analysisCases') isComposite and owningType <> null and (owningType.oclIsKindOf(AnalysisCaseDefinition) or owningType.oclIsKindOf(AnalysisCaseUsage)) implies specializesFromLibrary('AnalysisCases::AnalysisCase::subAnalysisCases')
subclass of: CaseUsage

analysisCaseDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The AnalysisCaseDefinition that is the definition of this AnalysisCaseUsage.
domain: AnalysisCaseUsage
range: AnalysisCaseDefinition
sub property of: caseDefinition

resultExpression
type: FunctionalProperty
type: ObjectProperty
comment: An Expression used to compute the result of the AnalysisCaseUsage, owned via a ResultExpressionMembership.
domain: AnalysisCaseUsage
range: Expression
sub property of: ownedFeature

AnnotatingElement
type: Class
comment: An AnnotatingElement is an Element that provides additional description of or metadata on some other Element. An AnnotatingElement is either attached to its annotatedElements by Annotation Relationships, or it implicitly annotates its owningNamespace. annotatedElement = if annotation->notEmpty() then annotation.annotatedElement else Sequence{owningNamespace} endif ownedAnnotatingRelationship = ownedRelationship-> selectByKind(Annotation)-> select(a | a.annotatingElement = self)
subclass of: Element

annotatedElement
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement.
domain: AnnotatingElement
range: Element

annotation
type: InverseFunctionalProperty
type: ObjectProperty
comment: The Annotations that relate this AnnotatingElement to its annotatedElements.
domain: AnnotatingElement
range: Annotation
inverse of: annotatingElement

ownedAnnotatingRelationship
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this AnnotatingElement that are Annotations, for which this AnnotatingElement is the annotatingElement.
domain: AnnotatingElement
range: Annotation
inverse of: owningAnnotatingElement

Annotation
type: Class
comment: An Annotation is a Relationship between an AnnotatingElement and the Element that is annotated by that AnnotatingElement.
subclass of: Restriction
  cardinality: 1
  on property: annotatedElement
subclass of: Restriction
  cardinality: 1
  on property: annotatingElement
subclass of: Relationship

annotatedElement
type: FunctionalProperty
type: ObjectProperty
comment: The Element that is annotated by the annotatingElement of this Annotation.
domain: Annotation
range: Element
sub property of: target

annotatingElement
type: FunctionalProperty
type: ObjectProperty
comment: The AnnotatingElement that annotates the annotatedElement of this Annotation.
domain: Annotation
range: AnnotatingElement
sub property of: source

owningAnnotatedElement
type: FunctionalProperty
type: ObjectProperty
comment: The annotatedElement of this Annotation, when it is also its owningRelatedElement.
domain: Annotation
range: Element
sub property of: annotatedElement
sub property of: owningRelatedElement

owningAnnotatingElement
type: FunctionalProperty
type: ObjectProperty
comment: The annotatingElement of this Annotation, when it is also its owningRelatedElement.
domain: Annotation
range: AnnotatingElement
sub property of: annotatingElement
sub property of: owningRelatedElement

AssertConstraintUsage
type: Class
comment: An AssertConstraintUsage is a ConstraintUsage that is also an Invariant and, so, is asserted to be true (by default). Unless it is the AssertConstraintUsage itself, the asserted ConstraintUsage is related to the AssertConstraintUsage by a ReferenceSubsetting Relationship. assertedConstraint = if ownedReferenceSubsetting = null then self else ownedReferenceSubsetting.referencedFeature.oclAsType(ConstraintUsage) endif if isNegated then specializesFromLibrary('Constraints::negatedConstraints') else specializesFromLibrary('Constraints::assertedConstraints') endif ownedReferenceSubsetting <> null implies ownedReferenceSubsetting.referencedFeature.oclIsKindOf(ConstraintUsage)
subclass of: Restriction
  cardinality: 1
  on property: assertedConstraint
subclass of: ConstraintUsage
subclass of: Invariant

assertedConstraint
type: FunctionalProperty
type: ObjectProperty
comment: The ConstraintUsage to be performed by the AssertConstraintUsage. It is the referenceFeature of the ownedReferenceSubsetting for the AssertConstraintUsage, if there is one, and, otherwise, the AssertConstraintUsage itself.
domain: AssertConstraintUsage
range: ConstraintUsage

AssignmentActionUsage
type: Class
comment: An AssignmentActionUsage is an ActionUsage that is defined, directly or indirectly, by the ActionDefinition AssignmentAction from the Systems Model Library. It specifies that the value of the referent Feature, relative to the target given by the result of the targetArgument Expression, should be set to the result of the valueExpression. specializesFromLibrary('Actions::assignmentActions') let targetParameter : Feature = inputParameter(1) in targetParameter <> null and targetParameter.ownedFeature->notEmpty() and targetParameter.ownedFeature->first(). redefines('AssignmentAction::target::startingAt') valueExpression = argument(2) targetArgument = argument(1) isSubactionUsage() implies specializesFromLibrary('Actions::Action::assignments') let targetParameter : Feature = inputParameter(1) in targetParameter <> null and targetParameter.ownedFeature->notEmpty() and targetParameter->first().ownedFeature->notEmpty() and targetParameter->first().ownedFeature->first(). redefines('AssigmentAction::target::startingAt::accessedFeature') let targetParameter : Feature = inputParameter(1) in targetParameter <> null and targetParameter.ownedFeature->notEmpty() and targetParameter->first().ownedFeature->notEmpty() and targetParameter->first().ownedFeature->first().redefines(referent) referent = let unownedFeatures : Sequence(Feature) = ownedMembership-> reject(oclIsKindOf(FeatureMembership)).memberElement-> selectByKind(Feature) in if unownedFeatures->isEmpty() then null else unownedFeatures->first().oclAsType(Feature) endif ownedMembership->exists( not oclIsKindOf(OwningMembership) and memberElement.oclIsKindOf(Feature))
subclass of: Restriction
  cardinality: 1
  on property: referent
subclass of: ActionUsage

referent
type: FunctionalProperty
type: ObjectProperty
comment: The Feature whose value is to be set.
domain: AssignmentActionUsage
range: Feature
sub property of: member

targetArgument
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose value is an occurrence in the domain of the referent Feature, for which the value of the referent will be set to the result of the valueExpression by this AssignmentActionUsage.
domain: AssignmentActionUsage
range: Expression

valueExpression
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result is to be assigned to the referent Feature.
domain: AssignmentActionUsage
range: Expression

Association
type: Class
comment: An Association is a Relationship and a Classifier to enable classification of links between things (in the universe). The co-domains (types) of the associationEnd Features are the relatedTypes, as co-domain and participants (linked things) of an Association identify each other. relatedType = associationEnd.type specializesFromLibrary('Links::Link') oclIsKindOf(Structure) = oclIsKindOf(AssociationStructure) associationEnd->size() = 2 implies specializesFromLibrary('Links::BinaryLink') not isAbstract implies relatedType->size() >= 2 associationEnds->size() > 2 implies not specializesFromLibrary('Links::BinaryLink') sourceType = if relatedType->isEmpty() then null else relatedType->first() endif targetType = if relatedType->size() < 2 then OrderedSet{} else relatedType-> subSequence(2, relatedType->size())-> asOrderedSet() endif
subclass of: Classifier
subclass of: Relationship

AssociationStructure
type: Class
comment: An AssociationStructure is an Association that is also a Structure, classifying link objects that are both links and objects. As objects, link objects can be created and destroyed, and their non-end Features can change over time. However, the values of the end Features of a link object are fixed and cannot change over its lifetime. specializesFromLibrary('Objects::LinkObject') endFeature->size() = 2 implies specializesFromLibrary('Objects::BinaryLinkObject')
subclass of: Association
subclass of: Structure

associationEnd
type: ObjectProperty
comment: The features of the Association that identify the things that can be related by it. A concrete Association must have at least two associationEnds. When it has exactly two, the Association is called a binary Association.
domain: Association
range: Feature
sub property of: endFeature

relatedType
is ordered: true
type: ObjectProperty
comment: The types of the associationEnds of the Association, which are the relatedElements of the Association considered as a Relationship.
domain: Association
range: Type
sub property of: relatedElement

sourceType
type: FunctionalProperty
type: ObjectProperty
comment: The source relatedType for this Association. It is the first relatedType of the Association.
domain: Association
range: Type
sub property of: relatedType
sub property of: source

targetType
type: ObjectProperty
comment: The target relatedTypes for this Association. This includes all the relatedTypes other than the sourceType.
domain: Association
range: Type
sub property of: relatedType
sub property of: target

AttributeDefinition
type: Class
comment: An AttributeDefinition is a Definition and a DataType of information about a quality or characteristic of a system or part of a system that has no independent identity other than its value. All features of an AttributeDefinition must be referential (non-composite). As a DataType, an AttributeDefinition must specialize, directly or indirectly, the base DataType Base::DataValue from the Kernel Semantic Library. feature->forAll(not isComposite)
subclass of: DataType
subclass of: Definition

AttributeUsage
type: Class
comment: An AttributeUsage is a Usage whose type is a DataType. Nominally, if the type is an AttributeDefinition, an AttributeUsage is a usage of a AttributeDefinition to represent the value of some system quality or characteristic. However, other kinds of kernel DataTypes are also allowed, to permit use of DataTypes from the Kernel Model Libraries. An AttributeUsage itself as well as all its nested features must be referential (non-composite). An AttributeUsage must specialize, directly or indirectly, the base Feature Base::dataValues from the Kernel Semantic Library. isReference feature->forAll(not isComposite) specializesFromLibrary('Base::dataValues')
subclass of: Usage

attributeDefinition
is ordered: true
type: ObjectProperty
comment: The DataTypes that are the types of this AttributeUsage. Nominally, these are AttributeDefinitions, but other kinds of kernel DataTypes are also allowed, to permit use of DataTypes from the Kernel Model Libraries.
domain: AttributeUsage
range: DataType
sub property of: definition

Behavior
type: Class
comment: A Behavior coordinates occurrences of other Behaviors, as well as changes in objects. Behaviors can be decomposed into Steps and be characterized by parameters. specializesFromLibrary('Performances::Performance') step = feature->selectByKind(Step) ownedSpecialization.general->forAll(not oclIsKindOf(Structure))
subclass of: Class

parameter
is ordered: true
type: ObjectProperty
comment: The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior.
domain: Behavior
range: Feature
sub property of: directedFeature

step
type: ObjectProperty
comment: The Steps that make up this Behavior.
domain: Behavior
range: Step
sub property of: feature

BindingConnector
type: Class
comment: A BindingConnector is a binary Connector that requires its relatedFeatures to identify the same things (have the same values). specializesFromLibrary('Links::selfLinks') relatedFeature->size() = 2
subclass of: Connector

BindingConnectorAsUsage
type: Class
comment: A BindingConnectorAsUsage is both a BindingConnector and a ConnectorAsUsage.
subclass of: BindingConnector
subclass of: ConnectorAsUsage

BooleanExpression
type: Class
comment: A BooleanExpression is a Boolean-valued Expression whose type is a Predicate. It represents a logical condition resulting from the evaluation of the Predicate. specializesFromLibrary('Performances::booleanEvaluations')
subclass of: Expression

predicate
type: FunctionalProperty
type: ObjectProperty
comment: The Predicate that types this BooleanExpression. The Predicate that types the Expression.
domain: BooleanExpression
range: Predicate
sub property of: function

CalculationDefinition
type: Class
comment: A CalculationDefinition is an <coed>ActionDefinition that also defines a Function producing a result. specializesFromLibrary('Calculations::Calculation') calculation = action->selectByKind(CalculationUsage)
subclass of: ActionDefinition
subclass of: Function

calculation
is ordered: true
type: ObjectProperty
comment: The actions of this CalculationDefinition that are CalculationUsages.
domain: CalculationDefinition
range: CalculationUsage
sub property of: action
sub property of: expression

CalculationUsage
type: Class
comment: A CalculationUsage is an ActionUsage that is also an Expression, and, so, is typed by a Function. Nominally, if the type is a CalculationDefinition, a CalculationUsage is a Usage of that CalculationDefinition within a system. However, other kinds of kernel Functions are also allowed, to permit use of Functions from the Kernel Model Libraries. specializesFromLibrary('Calculations::calculations') owningType <> null and (owningType.oclIsKindOf(CalculationDefinition) or owningType.oclIsKindOf(CalculationUsage)) implies specializesFromLibrary('Calculations::Calculation::subcalculations')
subclass of: ActionUsage
subclass of: Expression

calculationDefinition
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The <ode>Function that is the type of this CalculationUsage. Nominally, this would be a CalculationDefinition, but a kernel Function is also allowed, to permit use of Functions from the Kernel Model Libraries.
domain: CalculationUsage
range: Function
sub property of: actionDefinition
sub property of: function

CaseDefinition
type: Class
comment: A CaseDefinition is a CalculationDefinition for a process, often involving collecting evidence or data, relative to a subject, possibly involving the collaboration of one or more other actors, producing a result that meets an objective. objectiveRequirement = let objectives: OrderedSet(RequirementUsage) = featureMembership-> selectByKind(ObjectiveMembership). ownedRequirement in if objectives->isEmpty() then null else objectives->first().ownedObjectiveRequirement endif featureMembership-> selectByKind(ObjectiveMembership)-> size() <= 1 subjectParameter = let subjectMems : OrderedSet(SubjectMembership) = featureMembership->selectByKind(SubjectMembership) in if subjectMems->isEmpty() then null else subjectMems->first().ownedSubjectParameter endif actorParameter = featureMembership-> selectByKind(ActorMembership). ownedActorParameter featureMembership->selectByKind(SubjectMembership)->size() <= 1 input->notEmpty() and input->first() = subjectParameter specializesFromLibrary('Cases::Case')
subclass of: Restriction
  cardinality: 1
  on property: subjectParameter
subclass of: CalculationDefinition

actorParameter
is ordered: true
type: ObjectProperty
comment: The parameters of this CaseDefinition that represent actors involved in the case.
domain: CaseDefinition
range: PartUsage
sub property of: parameter
sub property of: usage

objectiveRequirement
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The RequirementUsage representing the objective of this CaseDefinition.
domain: CaseDefinition
range: RequirementUsage
sub property of: usage

subjectParameter
type: FunctionalProperty
type: ObjectProperty
comment: The parameter of this CaseDefinition that represents its subject.
domain: CaseDefinition
range: Usage
sub property of: parameter
sub property of: usage

CaseUsage
type: Class
comment: A CaseUsage is a Usage of a CaseDefinition. objectiveRequirement = let objectives: OrderedSet(RequirementUsage) = featureMembership-> selectByKind(ObjectiveMembership). ownedRequirement in if objectives->isEmpty() then null else objectives->first().ownedObjectiveRequirement endif featureMembership-> selectByKind(ObjectiveMembership)-> size() <= 1 featureMembership-> selectByKind(SubjectMembership)-> size() <= 1 actorParameter = featureMembership-> selectByKind(ActorMembership). ownedActorParameter subjectParameter = let subjects : OrderedSet(SubjectMembership) = featureMembership->selectByKind(SubjectMembership) in if subjects->isEmpty() then null else subjects->first().ownedSubjectParameter endif input->notEmpty() and input->first() = subjectParameter specializesFromLibrary('Cases::cases') isComposite and owningType <> null and (owningType.oclIsKindOf(CaseDefinition) or owningType.oclIsKindOf(CaseUsage)) implies specializesFromLibrary('Cases::Case::subcases')
subclass of: Restriction
  cardinality: 1
  on property: subjectParameter
subclass of: CalculationUsage

actorParameter
is ordered: true
type: ObjectProperty
comment: The parameters of this CaseUsage that represent actors involved in the case.
domain: CaseUsage
range: PartUsage
sub property of: parameter
sub property of: usage

caseDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The CaseDefinition that is the type of this CaseUsage.
domain: CaseUsage
range: CaseDefinition
sub property of: calculationDefinition

objectiveRequirement
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The RequirementUsage representing the objective of this CaseUsage.
domain: CaseUsage
range: RequirementUsage
sub property of: usage

subjectParameter
type: FunctionalProperty
type: ObjectProperty
comment: The parameter of this CaseUsage that represents its subject.
domain: CaseUsage
range: Usage
sub property of: parameter
sub property of: usage

Class
comment: A Class is a Classifier of things (in the universe) that can be distinguished without regard to how they are related to other things (via Features). This means multiple things classified by the same Class can be distinguished, even when they are related other things in exactly the same way. specializesFromLibrary('Occurrences::Occurrence') ownedSpecialization.general-> forAll(not oclIsKindOf(DataType)) and not oclIsKindOf(Association) implies ownedSpecialization.general-> forAll(not oclIsKindOf(Association))
subclass of: Classifier

Classifier
type: Class
comment: A Classifier is a Type that classifies: Things (in the universe) regardless of how Features relate them. (These are interpreted semantically as sequences of exactly one thing.) How the above things are related by Features. (These are interpreted semantically as sequences of multiple things, such that the last thing in the sequence is also classified by the Classifier. Note that this means that a Classifier modeled as specializing a Feature cannot classify anything.) ownedSubclassification = ownedSpecialization->selectByKind(Subclassification) multiplicity <> null implies multiplicity.featuringType->isEmpty()
subclass of: Type

ownedSubclassification
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedSpecializations of this Classifier that are Subclassifications, for which this Classifier is the subclassifier.
domain: Classifier
range: Subclassification
inverse of: owningClassifier

CollectExpression
type: Class
comment: A CollectExpression is an OperatorExpression whose operator is "collect", which resolves to the Function ControlFunctions::collect from the Kernel Functions Library. operator = "collect"
subclass of: OperatorExpression

Comment
type: Class
comment: A Comment is an AnnotatingElement whose body in some way describes its annotatedElements.
subclass of: Restriction
  cardinality: 1
  on property: body
subclass of: AnnotatingElement

body
type: DatatypeProperty
type: FunctionalProperty
comment: The annotation text for the Comment.
domain: Comment
range: string

locale
type: DatatypeProperty
type: FunctionalProperty
comment: Identification of the language of the body text and, optionally, the region and/or encoding. The format shall be a POSIX locale conformant to ISO/IEC 15897, with the format [language[_territory][.codeset][@modifier]].
domain: Comment
range: string

ConcernDefinition
type: Class
comment: A ConcernDefinition is a RequirementDefinition that one or more stakeholders may be interested in having addressed. These stakeholders are identified by the ownedStakeholdersof the ConcernDefinition. specializesFromLibrary('Requirements::ConcernCheck')
subclass of: RequirementDefinition

ConcernUsage
type: Class
comment: A ConcernUsage is a Usage of a ConcernDefinition. The ownedStakeholder features of the ConcernUsage shall all subset the ConcernCheck::concernedStakeholders feature. If the ConcernUsage is an ownedFeature of a StakeholderDefinition or StakeholderUsage, then the ConcernUsage shall have an ownedStakeholder feature that is bound to the self feature of its owner. specializesFromLibrary('Requirements::concernChecks') owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(FramedConcernMembership) implies specializesFromLibrary('Requirements::RequirementCheck::concerns')
subclass of: RequirementUsage

concernDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The ConcernDefinition that is the single type of this ConcernUsage.
domain: ConcernUsage
range: ConcernDefinition
sub property of: requirementDefinition

ConjugatedPortDefinition
type: Class
comment: A ConjugatedPortDefinition is a PortDefinition that is a PortDefinition of its original PortDefinition. That is, a ConjugatedPortDefinition inherits all the features of the original PortDefinition, but input flows of the original PortDefinition become outputs on the ConjugatedPortDefinition and output flows of the original PortDefinition become inputs on the ConjugatedPortDefinition. Every PortDefinition (that is not itself a ConjugatedPortDefinition) has exactly one corresponding ConjugatedPortDefinition, whose effective name is the name of the originalPortDefinition, with the character ~ prepended. ownedPortConjugator.originalPortDefinition = originalPortDefinition conjugatedPortDefinition = null
subclass of: Restriction
  cardinality: 1
  on property: originalPortDefinition
subclass of: Restriction
  cardinality: 1
  on property: ownedPortConjugator
subclass of: PortDefinition

originalPortDefinition
type: FunctionalProperty
type: InverseFunctionalProperty
type: ObjectProperty
comment: The original PortDefinition for this ConjugatedPortDefinition, which is the owningNamespace of the ConjugatedPortDefinition.
domain: ConjugatedPortDefinition
range: PortDefinition
inverse of: conjugatedPortDefinition

ownedPortConjugator
type: FunctionalProperty
type: InverseFunctionalProperty
type: ObjectProperty
comment: The PortConjugation that is the ownedConjugator of this ConjugatedPortDefinition, linking it to its originalPortDefinition.
domain: ConjugatedPortDefinition
range: PortConjugation
inverse of: conjugatedPortDefinition

ConjugatedPortTyping
type: Class
comment: A ConjugatedPortTyping is a FeatureTyping whose type is a ConjugatedPortDefinition. (This relationship is intended to be an abstract-syntax marker for a special surface notation for conjugated typing of ports.) portDefinition = conjugatedPortDefinition.originalPortDefinition
subclass of: Restriction
  cardinality: 1
  on property: conjugatedPortDefinition
subclass of: Restriction
  cardinality: 1
  on property: portDefinition
subclass of: FeatureTyping

conjugatedPortDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The type of this ConjugatedPortTyping considered as a FeatureTyping, which must be a ConjugatedPortDefinition.
domain: ConjugatedPortTyping
range: ConjugatedPortDefinition
sub property of: type

portDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The originalPortDefinition of the conjugatedPortDefinition of this ConjugatedPortTyping.
domain: ConjugatedPortTyping
range: PortDefinition

Conjugation
type: Class
comment: Conjugation is a Relationship between two types in which the conjugatedType inherits all the Features of the originalType, but with all input and output Features reversed. That is, any Features with a direction in relative to the originalType are considered to have an effective direction of out relative to the conjugatedType and, similarly, Features with direction out in the originalType are considered to have an effective direction of in in the conjugatedType. Features with direction inout, or with no direction, in the originalType, are inherited without change. A Type may participate as a conjugatedType in at most one Conjugation relationship, and such a Type may not also be the specific Type in any Specialization relationship.
subclass of: Restriction
  cardinality: 1
  on property: conjugatedType
subclass of: Restriction
  cardinality: 1
  on property: originalType
subclass of: Relationship

conjugatedType
type: FunctionalProperty
type: ObjectProperty
comment: The Type that is the result of applying Conjugation to the originalType.
domain: Conjugation
range: Type
sub property of: source

originalType
type: FunctionalProperty
type: ObjectProperty
comment: The Type to be conjugated.
domain: Conjugation
range: Type
sub property of: target

owningType
type: FunctionalProperty
type: ObjectProperty
comment: The conjugatedType of this Conjugation that is also its owningRelatedElement.
domain: Conjugation
range: Type
sub property of: conjugatedType
sub property of: owningRelatedElement

ConnectionDefinition
type: Class
comment: A ConnectionDefinition is a PartDefinition that is also an AssociationStructure. The end Features of a ConnectionDefinition must be Usages. specializesFromLibrary('Connections::Connection') ownedEndFeature->size() = 2 implies specializesFromLibrary('Connections::BinaryConnections')
subclass of: AssociationStructure
subclass of: PartDefinition

connectionEnd
is ordered: true
type: ObjectProperty
comment: The Usages that define the things related by the ConnectionDefinition.
domain: ConnectionDefinition
range: Usage
sub property of: associationEnd

ConnectionUsage
type: Class
comment: A ConnectionUsage is a ConnectorAsUsage that is also a PartUsage. Nominally, if its type is a ConnectionDefinition, then a ConnectionUsage is a Usage of that ConnectionDefinition, representing a connection between parts of a system. However, other kinds of kernel AssociationStructures are also allowed, to permit use of AssociationStructures from the Kernel Model Libraries. specializesFromLibrary('Connections::connections') ownedEndFeature->size() = 2 implies specializesFromLibrary('Connections::binaryConnections')
subclass of: ConnectorAsUsage
subclass of: PartUsage

connectionDefinition
is ordered: true
type: ObjectProperty
comment: The AssociationStructures that are the types of this ConnectionUsage. Nominally, these are , but other kinds of Kernel AssociationStructures are also allowed, to permit use of AssociationStructures from the Kernel Model Libraries
domain: ConnectionUsage
range: AssociationStructure
sub property of: association
sub property of: itemDefinition

Connector
type: Class
comment: A Connector is a usage of Associations, with links restricted according to instances of the Type in which they are used (domain of the Connector). The associations of the Connector restrict what kinds of things might be linked. The Connector further restricts these links to be between values of Features on instances of its domain. relatedFeature = connectorEnd.ownedReferenceSubsetting-> select(s | s <> null).subsettedFeature relatedFeature->forAll(f | if featuringType->isEmpty() then f.isFeaturedWithin(null) else featuringType->forAll(t | f.isFeaturedWithin(t)) endif) sourceFeature = if relatedFeature->isEmpty() then null else relatedFeature->first() endif targetFeature = if relatedFeature->size() < 2 then OrderedSet{} else relatedFeature-> subSequence(2, relatedFeature->size())-> asOrderedSet() endif not isAbstract implies relatedFeature->size() >= 2 specializesFromLibrary('Links::links') association->exists(oclIsKindOf(AssociationStructure)) implies specializesFromLibrary('Objects::linkObjects') connectorEnds->size() = 2 and association->exists(oclIsKindOf(AssocationStructure)) implies specializesFromLibrary('Objects::binaryLinkObjects') connectorEnd->size() = 2 implies specializesFromLibrary('Links::binaryLinks') connectorEnds->size() > 2 implies not specializesFromLibrary('Links::BinaryLink')
subclass of: Feature
subclass of: Relationship

ConnectorAsUsage
type: Class
comment: A ConnectorAsUsage is both a Connector and a Usage. ConnectorAsUsage cannot itself be instantiated in a SysML model, but it is the base class for the concrete classes BindingConnectorAsUsage, SuccessionAsUsage and ConnectionUsage.
subclass of: Connector
subclass of: Usage

association
is ordered: true
type: ObjectProperty
comment: The Associations that type the Connector.
domain: Connector
range: Association
sub property of: type

connectorEnd
is ordered: true
type: ObjectProperty
comment: The endFeatures of a Connector, which redefine the endFeatures of the associations of the Connector. The connectorEnds determine via ReferenceSubsetting Relationships which Features are related by the Connector.
domain: Connector
range: Feature
sub property of: endFeature

relatedFeature
is ordered: true
type: ObjectProperty
comment: The Features that are related by this Connector considered as a Relationship and that restrict the links it identifies, given by the referenced Features of the connectorEnds of the Connector.
domain: Connector
range: Feature
sub property of: relatedElement

sourceFeature
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The source relatedFeature for this Connector. It is the first relatedFeature.
domain: Connector
range: Feature
sub property of: relatedFeature
sub property of: source

targetFeature
is ordered: true
type: ObjectProperty
comment: The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature.
domain: Connector
range: Feature
sub property of: relatedFeature
sub property of: target

ConstraintDefinition
type: Class
comment: A ConstraintDefinition is an OccurrenceDefinition that is also a Predicate that defines a constraint that may be asserted to hold on a system or part of a system. specializesFromLibrary('Constraints::ConstraintCheck')
subclass of: OccurrenceDefinition
subclass of: Predicate

ConstraintUsage
type: Class
comment: A ConstraintUsage is an OccurrenceUsage that is also a BooleanExpression, and, so, is typed by a Predicate. Nominally, if the type is a ConstraintDefinition, a ConstraintUsage is a Usage of that ConstraintDefinition. However, other kinds of kernel Predicates are also allowed, to permit use of Predicates from the Kernel Model Libraries. owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(RequirementConstraintMembership) implies if owningFeatureMembership.oclAsType(RequirementConstraintMembership).kind = RequirementConstraintKind::assumption then specializesFromLibrary('Requirements::RequirementCheck::assumptions') else specializesFromLibrary('Requirements::RequirementCheck::constraints') endif specializesFromLibrary('Constraints::constraintChecks') owningType <> null and (owningType.oclIsKindOf(ItemDefinition) or owningType.oclIsKindOf(ItemUsage)) implies specializesFromLibrary('Items::Item::checkedConstraints')
subclass of: BooleanExpression
subclass of: OccurrenceUsage

constraintDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The (single) Predicate that is the type of this ConstraintUsage. Nominally, this will be a ConstraintDefinition, but other kinds of Predicates are also allowed, to permit use of Predicates from the Kernel Model Libraries.
domain: ConstraintUsage
range: Predicate
sub property of: predicate

ControlNode
type: Class
comment: A ControlNode is an ActionUsage that does not have any inherent behavior but provides constraints on incoming and outgoing Successions that are used to control other Actions. A ControlNode must be a composite owned usage of an ActionDefinition or ActionUsage. sourceConnector->selectByKind(Succession)-> collect(connectorEnd->at(1).multiplicity)-> forAll(sourceMult | multiplicityHasBounds(sourceMult, 1, 1)) owningType <> null and (owningType.oclIsKindOf(ActionDefinition) or owningType.oclIsKindOf(ActionUsage)) targetConnector->selectByKind(Succession)-> collect(connectorEnd->at(2).multiplicity)-> forAll(targetMult | multiplicityHasBounds(targetMult, 1, 1)) specializesFromLibrary('Action::Action::controls')
subclass of: ActionUsage

DataType
type: Class
comment: A DataType is a Classifier of things (in the universe) that can only be distinguished by how they are related to other things (via Features). This means multiple things classified by the same DataType Cannot be distinguished when they are related to other things in exactly the same way, even when they are intended to be about different things. Can be distinguished when they are related to other things in different ways, even when they are intended to be about the same thing. specializesFromLibrary('Base::DataValue') ownedSpecialization.general-> forAll(not oclIsKindOf(Class) and not oclIsKindOf(Association))
subclass of: Classifier

DecisionNode
type: Class
comment: A DecisionNode is a ControlNode that makes a selection from its outgoing Successions. targetConnector->selectByKind(Succession)->size() <= 1 sourceConnector->selectAsKind(Succession)-> collect(connectorEnd->at(2))-> forAll(targetMult | multiplicityHasBounds(targetMult, 0, 1)) specializesFromLibrary('Actions::Action::decisions') sourceConnector->selectByKind(Succession)-> forAll(subsetsChain(self, resolveGlobal('ControlPerformances::MergePerformance::outgoingHBLink')))
subclass of: ControlNode

Definition
type: Class
comment: A Definition is a Classifier of Usages. The actual kinds of Definition that may appear in a model are given by the subclasses of Definition (possibly as extended with user-defined SemanticMetadata). Normally, a Definition has owned Usages that model features of the thing being defined. A Definition may also have other Definitions nested in it, but this has no semantic significance, other than the nested scoping resulting from the Definition being considered as a Namespace for any nested Definitions. However, if a Definition has isVariation = true, then it represents a variation point Definition. In this case, all of its members must be variant Usages, related to the Definition by VariantMembership Relationships. Rather than being features of the Definition, variant Usages model different concrete alternatives that can be chosen to fill in for an abstract Usage of the variation point Definition. isVariation implies ownedFeatureMembership->isEmpty() variant = variantMembership.ownedVariantUsage variantMembership = ownedMembership->selectByKind(VariantMembership) isVariation implies not ownedSpecialization.specific->exists( oclIsKindOf(Definition) and oclAsType(Definition).isVariation) usage = feature->selectByKind(Usage) directedUsage = directedFeature->selectByKind(Usage) ownedUsage = ownedFeature->selectByKind(Usage) ownedAttribute = ownedUsage->selectByKind(AttributeUsage) ownedReference = ownedUsage->selectByKind(ReferenceUsage) ownedEnumeration = ownedUsage->selectByKind(EnumerationUsage) ownedOccurrence = ownedUsage->selectByKind(OccurrenceUsage) ownedItem = ownedUsage->selectByKind(ItemUsage) ownedPart = ownedUsage->selectByKind(PartUsage) ownedPort = ownedUsage->selectByKind(PortUsage) ownedConnection = ownedUsage->selectByKind(ConnectorAsUsage) ownedFlow = ownedUsage->selectByKind(FlowConnectionUsage) ownedInterface = ownedUsage->selectByKind(ReferenceUsage) ownedAllocation = ownedUsage->selectByKind(AllocationUsage) ownedAction = ownedUsage->selectByKind(Act…
subclass of: Restriction
  cardinality: 1
  on property: isVariation
subclass of: Classifier

directedUsage
is ordered: true
type: ObjectProperty
comment: The usages of this Definition that are directedFeatures.
domain: Definition
range: Usage
sub property of: usage
sub property of: directedFeature

isVariation
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships.
domain: Definition
range: boolean

ownedAction
is ordered: true
type: ObjectProperty
comment: The ActionUsages that are ownedUsages of this Definition.
domain: Definition
range: ActionUsage
sub property of: ownedOccurrence

ownedAllocation
is ordered: true
type: ObjectProperty
comment: The AllocationUsages that are ownedUsages of this Definition.
domain: Definition
range: AllocationUsage
sub property of: ownedConnection

ownedAnalysisCase
is ordered: true
type: ObjectProperty
comment: The AnalysisCaseUsages that are ownedUsages of this Definition.
domain: Definition
range: AnalysisCaseUsage
sub property of: ownedCase

ownedAttribute
is ordered: true
type: ObjectProperty
comment: The AttributeUsages that are ownedUsages of this Definition.
domain: Definition
range: AttributeUsage
sub property of: ownedUsage

ownedCalculation
is ordered: true
type: ObjectProperty
comment: The CalculationUsages that are ownedUsages of this Definition.
domain: Definition
range: CalculationUsage
sub property of: ownedAction

ownedCase
is ordered: true
type: ObjectProperty
comment: The code>CaseUsages that are ownedUsages of this Definition.
domain: Definition
range: CaseUsage
sub property of: ownedCalculation

ownedConcern
type: ObjectProperty
comment: The ConcernUsages that are ownedUsages of this Definition.
domain: Definition
range: ConcernUsage
sub property of: ownedRequirement

ownedConnection
is ordered: true
type: ObjectProperty
comment: The ConnectorAsUsages that are ownedUsages of this Definition. Note that this list includes BindingConnectorAsUsages and SuccessionAsUsages, even though these are ConnectorAsUsages but not ConnectionUsages.
domain: Definition
range: ConnectorAsUsage
sub property of: ownedPart

ownedConstraint
is ordered: true
type: ObjectProperty
comment: The ConstraintUsages that are ownedUsages of this Definition.
domain: Definition
range: ConstraintUsage
sub property of: ownedOccurrence

ownedEnumeration
is ordered: true
type: ObjectProperty
comment: The EnumerationUsages that are ownedUsages of this Definition.
domain: Definition
range: EnumerationUsage
sub property of: ownedAttribute

ownedFlow
type: ObjectProperty
comment: The FlowConnectionUsages that are ownedUsages of this Definition.
domain: Definition
range: FlowConnectionUsage
sub property of: ownedConnection

ownedInterface
is ordered: true
type: ObjectProperty
comment: The InterfaceUsages that are ownedUsages of this Definition.
domain: Definition
range: InterfaceUsage
sub property of: ownedConnection

ownedItem
is ordered: true
type: ObjectProperty
comment: The ItemUsages that are ownedUsages of this Definition.
domain: Definition
range: ItemUsage
sub property of: ownedOccurrence

ownedMetadata
is ordered: true
type: ObjectProperty
comment: The MetadataUsages that are ownedUsages of this Definition.
domain: Definition
range: MetadataUsage
sub property of: ownedItem

ownedOccurrence
is ordered: true
type: ObjectProperty
comment: The OccurrenceUsages that are ownedUsages of this Definition.
domain: Definition
range: OccurrenceUsage
sub property of: ownedUsage

ownedPart
is ordered: true
type: ObjectProperty
comment: The PartUsages that are ownedUsages of this Definition.
domain: Definition
range: PartUsage
sub property of: ownedItem

ownedPort
is ordered: true
type: ObjectProperty
comment: The PortUsages that are ownedUsages of this Definition.
domain: Definition
range: PortUsage
sub property of: ownedUsage

ownedReference
is ordered: true
type: ObjectProperty
comment: The ReferenceUsages that are ownedUsages of this Definition.
domain: Definition
range: ReferenceUsage
sub property of: ownedUsage

ownedRendering
is ordered: true
type: ObjectProperty
comment: The RenderingUsages that are ownedUsages of this Definition.
domain: Definition
range: RenderingUsage
sub property of: ownedPart

ownedRequirement
is ordered: true
type: ObjectProperty
comment: The RequirementUsages that are ownedUsages of this Definition.
domain: Definition
range: RequirementUsage
sub property of: ownedConstraint

ownedState
is ordered: true
type: ObjectProperty
comment: The StateUsages that are ownedUsages of this Definition.
domain: Definition
range: StateUsage
sub property of: ownedAction

ownedTransition
type: ObjectProperty
comment: The TransitionUsages that are ownedUsages of this Definition.
domain: Definition
range: TransitionUsage
sub property of: ownedUsage

ownedUsage
is ordered: true
type: ObjectProperty
comment: The Usages that are ownedFeatures of this Definition.
domain: Definition
range: Usage
sub property of: usage
sub property of: ownedFeature

ownedUseCase
is ordered: true
type: ObjectProperty
comment: The UseCaseUsages that are ownedUsages of this Definition.
domain: Definition
range: UseCaseUsage
sub property of: ownedCase

ownedVerificationCase
is ordered: true
type: ObjectProperty
comment: The VerificationCaseUsages that are ownedUsages of this Definition.
domain: Definition
range: VerificationCaseUsage
sub property of: ownedCase

ownedView
is ordered: true
type: ObjectProperty
comment: The ViewUsages that are ownedUsages of this Definition.
domain: Definition
range: ViewUsage
sub property of: ownedPart

ownedViewpoint
is ordered: true
type: ObjectProperty
comment: The ViewpointUsages that are ownedUsages of this Definition.
domain: Definition
range: ViewpointUsage
sub property of: ownedRequirement

usage
is ordered: true
type: ObjectProperty
comment: The Usages that are features of this Definition (not necessarily owned).
domain: Definition
range: Usage
sub property of: feature

variant
type: ObjectProperty
comment: The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants.
domain: Definition
range: Usage
sub property of: ownedMember

variantMembership
type: ObjectProperty
comment: The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty.
domain: Definition
range: VariantMembership
sub property of: ownedMembership

Dependency
type: Class
comment: A Dependency is a Relationship that indicates that one or more client Elements require one more supplier Elements for their complete specification. In general, this means that a change to one of the supplier Elements may necessitate a change to, or re-specification of, the client Elements. Note that a Dependency is entirely a model-level Relationship, without instance-level semantics.
subclass of: Restriction
  min cardinality: 1
  on property: client
subclass of: Restriction
  min cardinality: 1
  on property: supplier
subclass of: Relationship

client
is ordered: true
type: ObjectProperty
comment: The Element or Elements dependent on the supplier Elements.
domain: Dependency
range: Element
sub property of: source

supplier
is ordered: true
type: ObjectProperty
comment: The Element or Elements on which the client Elements depend in some respect.
domain: Dependency
range: Element
sub property of: target

Differencing
type: Class
comment: Differencing is a Relationship that makes its differencingType one of the differencingTypes of its typeDifferenced.
subclass of: Restriction
  cardinality: 1
  on property: differencingType
subclass of: Restriction
  cardinality: 1
  on property: typeDifferenced
subclass of: Relationship

differencingType
type: FunctionalProperty
type: ObjectProperty
comment: Type that partly determines interpretations of typeDifferenced, as described in Type::differencingType.
domain: Differencing
range: Type
sub property of: target

typeDifferenced
type: FunctionalProperty
type: ObjectProperty
comment: Type with interpretations partly determined by differencingType, as described in Type::differencingType.
domain: Differencing
range: Type
sub property of: owningRelatedElement
sub property of: source

Disjoining
type: Class
comment: A Disjoining is a Relationship between Types asserted to have interpretations that are not shared (disjoint) between them, identified as typeDisjoined and disjoiningType. For example, a Classifier for mammals is disjoint from a Classifier for minerals, and a Feature for people's parents is disjoint from a Feature for their children.
subclass of: Restriction
  cardinality: 1
  on property: disjoiningType
subclass of: Restriction
  cardinality: 1
  on property: typeDisjoined
subclass of: Relationship

disjoiningType
type: FunctionalProperty
type: ObjectProperty
comment: Type asserted to be disjoint with the typeDisjoined.
domain: Disjoining
range: Type
sub property of: target

owningType
type: FunctionalProperty
type: ObjectProperty
comment: A typeDisjoined that is also an owningRelatedElement.
domain: Disjoining
range: Type
sub property of: typeDisjoined
sub property of: owningRelatedElement

typeDisjoined
type: FunctionalProperty
type: ObjectProperty
comment: Type asserted to be disjoint with the disjoiningType.
domain: Disjoining
range: Type
sub property of: source

Documentation
type: Class
comment: Documentation is a Comment that specifically documents a documentedElement, which must be its owner.
subclass of: Restriction
  cardinality: 1
  on property: documentedElement
subclass of: Comment

documentedElement
type: FunctionalProperty
type: ObjectProperty
comment: The Element that is documented by this Documentation.
domain: Documentation
range: Element
sub property of: annotatedElement
inverse of: documentation

Element
type: Class
comment: An Element is a constituent of a model that is uniquely identified relative to all other Elements. It can have Relationships with other Elements. Some of these Relationships might imply ownership of other Elements, which means that if an Element is deleted from a model, then so are all the Elements that it owns. ownedElement = ownedRelationship.ownedRelatedElement owner = owningRelationship.owningRelatedElement qualifiedName = if owningNamespace = null then null else if owningNamespace.owner = null then escapedName() else if owningNamespace.qualifiedName = null or escapedName() = null then null else owningNamespace.qualifiedName + '::' + escapedName() endif endif endif documentation = ownedElement->selectByKind(Documentation) ownedAnnotation = ownedRelationship-> selectByKind(Annotation)-> select(a | a.annotatedElement = self) name = effectiveName() ownedRelationship->exists(isImplied) implies isImpliedIncluded isLibraryElement = libraryNamespace() <> null shortName = effectiveShortName() owningNamespace = if owningMembership = null then null else owningMembership.membershipOwningNamespace endif textualRepresentation = ownedElement->selectByKind(TextualRepresentation)
subclass of: Restriction
  cardinality: 1
  on property: elementId
subclass of: Restriction
  cardinality: 1
  on property: isImpliedIncluded
subclass of: Restriction
  cardinality: 1
  on property: isLibraryElement

ElementFilterMembership
type: Class
comment: ElementFilterMembership is a Membership between a Namespace and a model-level evaluable Boolean-valued Expression, asserting that imported members of the Namespace should be filtered using the condition Expression. A general Namespace does not define any specific filtering behavior, but such behavior may be defined for various specialized kinds of Namespaces. condition.isModelLevelEvaluable condition.result.specializesFromLibrary('ScalarValues::Boolean')
subclass of: Restriction
  cardinality: 1
  on property: condition
subclass of: OwningMembership

condition
type: FunctionalProperty
type: ObjectProperty
comment: The model-level evaluable Boolean-valued Expression used to filter the imported members of the membershipOwningNamespace of this ElementFilterMembership.
domain: ElementFilterMembership
range: Expression
sub property of: ownedMemberElement

aliasIds
is ordered: true
type: DatatypeProperty
comment: Various alternative identifiers for this Element. Generally, these will be set by tools.
domain: Element
range: string

declaredName
type: DatatypeProperty
type: FunctionalProperty
comment: The declared name of this Element.
domain: Element
range: string

declaredShortName
type: DatatypeProperty
type: FunctionalProperty
comment: An optional alternative name for the Element that is intended to be shorter or in some way more succinct than its primary name. It may act as a modeler-specified identifier for the Element, though it is then the responsibility of the modeler to maintain the uniqueness of this identifier within a model or relative to some other context.
domain: Element
range: string

documentation
is ordered: true
type: InverseFunctionalProperty
type: ObjectProperty
comment: The Documentation owned by this Element.
domain: Element
range: Documentation
sub property of: ownedElement

elementId
type: DatatypeProperty
type: FunctionalProperty
comment: The globally unique identifier for this Element. This is intended to be set by tooling, and it must not change during the lifetime of the Element.
domain: Element
range: string

isImpliedIncluded
type: DatatypeProperty
type: FunctionalProperty
comment: Whether all necessary implied Relationships have been included in the ownedRelationships of this Element. This property may be true, even if there are not actually any ownedRelationships with isImplied = true, meaning that no such Relationships are actually implied for this Element. However, if it is false, then ownedRelationships may not contain any implied Relationships. That is, either all required implied Relationships must be included, or none of them.
domain: Element
range: boolean

isLibraryElement
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Element is contained in the ownership tree of a library model.
domain: Element
range: boolean

name
type: DatatypeProperty
type: FunctionalProperty
comment: The name to be used for this Element during name resolution within its owningNamespace. This is derived using the effectiveName() operation. By default, it is the same as the declaredName, but this is overridden for certain kinds of Elements to compute a name even when the declaredName is null.
domain: Element
range: string

ownedAnnotation
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Element that are Annotations, for which this Element is the annotatedElement.
domain: Element
range: Annotation
inverse of: owningAnnotatedElement

ownedElement
is ordered: true
type: ObjectProperty
comment: The Elements owned by this Element, derived as the ownedRelatedElements of the ownedRelationships of this Element.
domain: Element
range: Element

ownedRelationship
type: InverseFunctionalProperty
type: ObjectProperty
comment: The Relationships for which this Element is the owningRelatedElement .
domain: Element
range: Relationship
inverse of: owningRelatedElement

owner
type: ObjectProperty
comment: The owner of this Element, derived as the owningRelatedElement of the owningRelationship of this Element, if any.
domain: Element
range: Element
inverse of: ownedElement

owningMembership
type: InverseFunctionalProperty
type: ObjectProperty
comment: The owningRelationship of this Element, if that Relationship is a Membership.
domain: Element
range: OwningMembership
inverse of: ownedMemberElement

owningNamespace
type: ObjectProperty
comment: The Namespace that owns this Element, which is the membershipOwningNamespace of the owningMembership of this Element, if any.
domain: Element
range: Namespace
inverse of: ownedMember

owningRelationship
type: ObjectProperty
comment: The Relationship for which this Element is an ownedRelatedElement , if any.
domain: Element
range: Relationship
inverse of: ownedRelatedElement

qualifiedName
type: DatatypeProperty
type: FunctionalProperty
comment: The full ownership-qualified name of this Element, represented in a form that is valid according to the KerML textual concrete syntax for qualified names (including use of unrestricted name notation and escaped characters, as necessary). The qualifiedName is null if this Element has no owningNamespace or if there is not a complete ownership chain of named Namespaces from a root Namespace to this Element.
domain: Element
range: string

shortName
type: DatatypeProperty
type: FunctionalProperty
comment: The short name to be used for this Element during name resolution within its owningNamespace. This is derived using the effectiveShortName() operation. By default, it is the same as the declaredShortName, but this is overridden for certain kinds of Elements to compute a shortName even when the declaredName is null.
domain: Element
range: string

textualRepresentation
is ordered: true
type: InverseFunctionalProperty
type: ObjectProperty
comment: The TextualRepresentations that annotate this Element.
domain: Element
range: TextualRepresentation
sub property of: ownedElement

EndFeatureMembership
type: Class
comment: EndFeatureMembership is a FeatureMembership that requires its memberFeature be owned and have isEnd = true. ownedMemberFeature.isEnd
subclass of: FeatureMembership

EnumerationDefinition
type: Class
comment: An EnumerationDefinition is an AttributeDefinition all of whose instances are given by an explicit list of enumeratedValues. This is realized by requiring that the EnumerationDefinition have isVariation = true, with the enumeratedValues being its variants. isVariation
subclass of: AttributeDefinition

enumeratedValue
is ordered: true
type: ObjectProperty
comment: EnumerationUsages of this EnumerationDefinitionthat have distinct, fixed values. Each enumeratedValue specifies one of the allowed instances of the EnumerationDefinition.
domain: EnumerationDefinition
range: EnumerationUsage
sub property of: variant

EnumerationUsage
type: Class
comment: An EnumerationUsage is an AttributeUsage whose attributeDefinition is an EnumerationDefinition.
subclass of: Restriction
  cardinality: 1
  on property: enumerationDefinition
subclass of: AttributeUsage

enumerationDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The single EnumerationDefinition that is the type of this EnumerationUsage.
domain: EnumerationUsage
range: EnumerationDefinition
sub property of: attributeDefinition

EventOccurrenceUsage
type: Class
comment: An EventOccurrenceUsage is an OccurrenceUsage that represents another OccurrenceUsage occurring as a suboccurrence of the containing occurrence of the EventOccurrenceUsage. Unless it is the EventOccurrenceUsage itself, the referenced OccurrenceUsage is related to the EventOccurrenceUsage by a ReferenceSubsetting Relationship. If the EventOccurrenceUsage is owned by an OccurrenceDefinition or OccurrenceUsage, then it also subsets the timeEnclosedOccurrences property of the Class Occurrence from the Kernel Semantic Library model Occurrences. eventOccurrence = if ownedReferenceSubsetting = null then self else if ownedReferenceSubsetting.referencedFeature.oclIsKindOf(OccurrenceUsage) then ownedReferenceSubsetting.referencedFeature.oclAsType(OccurrenceUsage) else null endif endif ownedReferenceSubsetting <> null implies ownedReferenceSubsetting.referencedFeature.oclIsKindOf(OccurrenceUsage) owningType <> null and (owningType.oclIsKindOf(OccurrenceDefinition) or owningType.oclIsKindOf(OccurrenceUsage)) implies specializesFromLibrary('Occurrences::Occurrence::timeEnclosedOccurrences') isReference
subclass of: Restriction
  cardinality: 1
  on property: eventOccurrence
subclass of: OccurrenceUsage

eventOccurrence
type: FunctionalProperty
type: ObjectProperty
comment: The OccurrenceUsage referenced as an event by this EventOccurrenceUsage. It is the referenceFeature of the ownedReferenceSubsetting for the EventOccurrenceUsage, if there is one, and, otherwise, the EventOccurrenceUsage itself.
domain: EventOccurrenceUsage
range: OccurrenceUsage

ExhibitStateUsage
type: Class
comment: An ExhibitStateUsage is a StateUsage that represents the exhibiting of a StateUsage. Unless it is the StateUsage itself, the StateUsage to be exhibited is related to the ExhibitStateUsage by a ReferenceSubsetting Relationship. An ExhibitStateUsage is also a PerformActionUsage, with its exhibitedState as the performedAction. owningType <> null and (owningType.oclIsKindOf(PartDefinition) or owningType.oclIsKindOf(PartUsage)) implies specializesFromLibrary('Parts::Part::exhibitedStates') ownedReferenceSubsetting <> null implies ownedReferenceSubsetting.referencedFeature.oclIsKindOf(StateUsage)
subclass of: Restriction
  cardinality: 1
  on property: exhibitedState
subclass of: PerformActionUsage
subclass of: StateUsage

exhibitedState
type: FunctionalProperty
type: ObjectProperty
comment: The StateUsage to be exhibited by the ExhibitStateUsage. It is the performedAction of the ExhibitStateUsage considered as a PerformActionUsage, which must be a StateUsage.
domain: ExhibitStateUsage
range: StateUsage
sub property of: performedAction

Expose
type: Class
comment: An Expose is an Import of Memberships into a ViewUsage that provide the Elements to be included in a view. Visibility is always ignored for an Expose (i.e., isImportAll = true). isImportAll importOwningNamespace.oclIsType(ViewUsage) visibility = VisibilityKind::protected
subclass of: Import

Expression
type: Class
comment: An Expression is a Step that is typed by a Function. An Expression that also has a Function as its featuringType is a computational step within that Function. An Expression always has a single result parameter, which redefines the result parameter of its defining function. This allows Expressions to be interconnected in tree structures, in which inputs to each Expression in the tree are determined as the results of other Expression in the tree. isModelLevelEvaluable = modelLevelEvaluable(Set(Element){}) specializesFromLibrary('Performances::evaluations') owningMembership <> null and owningMembership.oclIsKindOf(FeatureValue) implies let featureWithValue : Feature = owningMembership.oclAsType(FeatureValue).featureWithValue in featuringType = featureWithValue.featuringType ownedMembership.selectByKind(ResultExpressionMembership)-> forAll(mem | ownedFeature.selectByKind(BindingConnector)-> exists(binding | binding.relatedFeature->includes(result) and binding.relatedFeature->includes(mem.ownedResultExpression.result))) result = let resultParams : Sequence(Feature) = ownedFeatureMemberships-> selectByKind(ReturnParameterMembership). ownedParameterMember in if resultParams->notEmpty() then resultParams->first() else if function <> null then function.result else null endif endif ownedFeatureMembership-> selectByKind(ReturnParameterMembership)-> size() <= 1 membership->selectByKind(ResultExpressionMembership)->size() <= 1
subclass of: Restriction
  cardinality: 1
  on property: result
subclass of: Restriction
  cardinality: 1
  on property: isModelLevelEvaluable
subclass of: Step

function
type: FunctionalProperty
type: ObjectProperty
comment: The Function that types this Expression. This is the Function that types the Expression.
domain: Expression
range: Function
sub property of: behavior

isModelLevelEvaluable
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model.
domain: Expression
range: boolean

result
type: FunctionalProperty
type: ObjectProperty
comment: An output parameter of the Expression whose value is the result of the Expression. The result of an Expression is either inherited from its function or it is related to the Expression via a ReturnParameterMembership, in which case it redefines the result parameter of its function.
domain: Expression
range: Feature
sub property of: parameter
sub property of: output

Feature
type: Class
comment: A Feature is a Type that classifies relations between multiple things (in the universe). The domain of the relation is the intersection of the featuringTypes of the Feature. (The domain of a Feature with no featuringTyps is implicitly the most general Type Base::Anything from the Kernel Semantic Library.) The co-domain of the relation is the intersection of the types of the Feature. In the simplest cases, the featuringTypes and types are Classifiers and the Feature relates two things, one from the domain and one from the range. Examples include cars paired with wheels, people paired with other people, and cars paired with numbers representing the car length. Since Features are Types, their featuringTypes and types can be Features. In this case, the Feature effectively classifies relations between relations, which can be interpreted as the sequence of things related by the domain Feature concatenated with the sequence of things related by the co-domain Feature. The values of a Feature for a given instance of its domain are all the instances of its co-domain that are related to that domain instance by the Feature. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with values of the first Feature, then using those values as domain instances to obtain valus of the second Feature, and so on, to values of the last Feature. ownedRedefinition = ownedSubsetting->selectByKind(Redefinition) ownedTypeFeaturing = ownedRelationship->selectByKind(TypeFeaturing)-> select(tf | tf.featureOfType = self) ownedSubsetting = ownedSpecialization->selectByKind(Subsetting) ownedTyping = ownedGeneralization->selectByKind(FeatureTyping) type = let types : OrderedSet(Types) = OrderedSet{self}-> -- Note: The closure operation automatically handles circular relationships. closure(typingFeatures()).typing.type->asOrderedSet() in types->reject(t1 | types->exist(t2 | t2 <> t1 and t2.specializes(t1))) multiplicity <> …
subclass of: Restriction
  cardinality: 1
  on property: featureTarget
subclass of: Restriction
  cardinality: 1
  on property: isComposite
subclass of: Restriction
  cardinality: 1
  on property: isDerived
subclass of: Restriction
  cardinality: 1
  on property: isEnd
subclass of: Restriction
  cardinality: 1
  on property: isNonunique
subclass of: Restriction
  cardinality: 1
  on property: isOrdered
subclass of: Restriction
  cardinality: 1
  on property: isPortion
subclass of: Restriction
  cardinality: 1
  on property: isReadOnly
subclass of: Restriction
  cardinality: 1
  on property: isUnique
subclass of: Type

FeatureChainExpression
type: Class
comment: A FeatureChainExpression is an OperatorExpression whose operator is ".", which resolves to the Function ControlFunctions::'.' from the Kernel Functions Library. It evaluates to the result of chaining the result Feature of its single argument Expression with its targetFeature. let sourceParameter : Feature = sourceTargetFeature() in sourceTargetFeature <> null and sourceTargetFeature.redefinesFromLibrary('ControlFunctions::\'.\'::source::target') let sourceParameter : Feature = sourceTargetFeature() in sourceTargetFeature <> null and sourceTargetFeature.redefines(targetFeature) targetFeature = let nonParameterMemberships : Sequence(Membership) = ownedMembership-> reject(oclIsKindOf(ParameterMembership)) in if nonParameterMemberships->isEmpty() or not nonParameterMemberships->first().memberElement.oclIsKindOf(Feature) then null else nonParameterMemberships->first().memberElement.oclAsType(Feature) endif argument->notEmpty() implies targetFeature.featuringType->forAll(t | t.specializes(argument->at(1).result))
subclass of: Restriction
  cardinality: 1
  on property: targetFeature
subclass of: OperatorExpression

targetFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.
domain: FeatureChainExpression
range: Feature
sub property of: member

FeatureChaining
type: Class
comment: FeatureChaining is a Relationship that makes its target Feature one of the chainingFeatures of its owning Feature.
subclass of: Restriction
  cardinality: 1
  on property: chainingFeature
subclass of: Restriction
  cardinality: 1
  on property: featureChained
subclass of: Relationship

chainingFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature whose values partly determine values of featureChained, as described in Feature::chainingFeature.
domain: FeatureChaining
range: Feature
sub property of: target

featureChained
type: FunctionalProperty
type: ObjectProperty
comment: The Feature whose values are partly determined by values of the chainingFeature, as described in Feature::chainingFeature.
domain: FeatureChaining
range: Feature
sub property of: owningRelatedElement
sub property of: source

FeatureDirectionKind
type: Datatype
comment: FeatureDirectionKind enumerates the possible kinds of direction that a Feature may be given as a member of a Type.
equivalent class: Datatype
  one of: in
  one of: inout
  one of: out

FeatureInverting
type: Class
comment: A FeatureInverting is a Relationship between Features asserting that their interpretations (sequences) are the reverse of each other, identified as featureInverted and invertingFeature. For example, a Feature identifying each person's parents is the inverse of a Feature identifying each person's children. A person identified as a parent of another will identify that other as one of their children.
subclass of: Restriction
  cardinality: 1
  on property: featureInverted
subclass of: Restriction
  cardinality: 1
  on property: invertingFeature
subclass of: Relationship

featureInverted
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is an inverse of the invertingFeature.
domain: FeatureInverting
range: Feature
sub property of: source

invertingFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is an inverse of the invertedFeature.
domain: FeatureInverting
range: Feature
sub property of: target

owningFeature
type: FunctionalProperty
type: ObjectProperty
comment: A featureInverted that is also the owningRelatedElement of this FeatureInverting.
domain: FeatureInverting
range: Feature
sub property of: featureInverted
sub property of: owningRelatedElement

FeatureMembership
type: Class
comment: A FeatureMembership is an OwningMembership between a Feature in an owningType that is also a Featuring Relationship between the Feature and the Type, in which the featuringType is the source and the featureOfType is the target. A FeatureMembership is always owned by its owningType, which is the featuringType for the FeatureMembership considered as a Featuring.
subclass of: Restriction
  cardinality: 1
  on property: ownedMemberFeature
subclass of: Restriction
  cardinality: 1
  on property: owningType
subclass of: Featuring
subclass of: OwningMembership

ownedMemberFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that this FeatureMembership relates to its owningType, making it an ownedFeature of the owningType.
domain: FeatureMembership
range: Feature
sub property of: feature
sub property of: ownedMemberElement

owningType
type: FunctionalProperty
type: ObjectProperty
comment: The Type that owns this FeatureMembership.
domain: FeatureMembership
range: Type
sub property of: type
sub property of: membershipOwningNamespace

FeatureReferenceExpression
type: Class
comment: A FeatureReferenceExpression is an Expression whose result is bound to a referent Feature. referent = let nonParameterMemberships : Sequence(Membership) = ownedMembership-> reject(oclIsKindOf(ParameterMembership)) in if nonParameterMemberships->isEmpty() or not nonParameterMemberships->first().memberElement.oclIsKindOf(Feature) then null else nonParameterMemberships->first().memberElement.oclAsType(Feature) endif ownedMember->selectByKind(BindingConnector)->exists(b | b.relatedFeatures->includes(targetFeature) and b.relatedFeatures->includes(result)) let membership : Membership = ownedMembership->reject(m | m.oclIsKindOf(ParameterMembership)) in membership->notEmpty() and membership->at(1).memberElement.oclIsKindOf(Feature)
subclass of: Restriction
  cardinality: 1
  on property: referent
subclass of: Expression

referent
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is referenced by this FeatureReferenceExpression, which is its first non-parameter member.
domain: FeatureReferenceExpression
range: Feature
sub property of: member

FeatureTyping
type: Class
comment: FeatureTyping is Specialization in which the specific Type is a Feature. This means the set of instances of the (specific) typedFeature is a subset of the set of instances of the (general) type. In the simplest case, the type is a Classifier, whereupon the typedFeature has values that are instances of the Classifier.
subclass of: Restriction
  cardinality: 1
  on property: type
subclass of: Restriction
  cardinality: 1
  on property: typedFeature
subclass of: Specialization

owningFeature
type: FunctionalProperty
type: ObjectProperty
comment: A typedFeature that is also the owningRelatedElement of this FeatureTyping.
domain: FeatureTyping
range: Feature
sub property of: typedFeature
sub property of: owningType

type
type: FunctionalProperty
type: ObjectProperty
comment: The Type that is being applied by this FeatureTyping.
domain: FeatureTyping
range: Type
sub property of: general

typedFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that has a type determined by this FeatureTyping.
domain: FeatureTyping
range: Feature
sub property of: specific

FeatureValue
type: Class
comment: A FeatureValue is a Membership that identifies a particular member Expression that provides the value of the Feature that owns the FeatureValue. The value is specified as either a bound value or an initial value, and as either a concrete or default value. A Feature can have at most one FeatureValue. The result of the value Expression is bound to the featureWithValue using a BindingConnector. If isInitial = false, then the featuringType of the BindingConnector is the same as the featuringType of the featureWithValue. If isInitial = true, then the featuringType of the BindingConnector is restricted to its startShot. If isDefault = false, then the above semantics of the FeatureValue are realized for the given featureWithValue. Otherwise, the semantics are realized for any individual of the featuringType of the featureWithValue, unless another value is explicitly given for the featureWithValue for that individual. not isDefault implies featureWithValue.ownedMember-> selectByKind(BindingConnector)->exists(b | b.relatedFeature->includes(featureWithValue) and b.relatedFeature->includes(value.result) and if not isInitial then b.featuringType = featureWithValue.featuringType else b.featuringType->exists(t | t.oclIsKindOf(Feature) and t.oclAsType(Feature).chainingFeature = Sequence{ resolveGlobal('Base::things::that'). memberElement, resolveGlobal('Occurrences::Occurrence::startShot'). memberElement } ) endif) featureWithValue.redefinition.redefinedFeature-> closure(redefinition.redefinedFeature).valuation-> forAll(isDefault)
subclass of: Restriction
  cardinality: 1
  on property: featureWithValue
subclass of: Restriction
  cardinality: 1
  on property: value
subclass of: Restriction
  cardinality: 1
  on property: isDefault
subclass of: Restriction
  cardinality: 1
  on property: isInitial
subclass of: OwningMembership

featureWithValue
type: FunctionalProperty
type: ObjectProperty
comment: The Feature to be provided a value. The Feature to be provided a value.
domain: FeatureValue
range: Feature
sub property of: membershipOwningNamespace

isDefault
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this FeatureValue is a concrete specification of the bound or initial value of the featureWithValue, or just a default value that may be overridden.
domain: FeatureValue
range: boolean

isInitial
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this FeatureValue specifies a bound value or an initial value for the featureWithValue.
domain: FeatureValue
range: boolean

value
type: FunctionalProperty
type: ObjectProperty
comment: The Expression that provides the value of the featureWithValue as its result. The Expression that provides the value as a result.
domain: FeatureValue
range: Expression
sub property of: ownedMemberElement

chainingFeature
is ordered: true
type: ObjectProperty
comment: The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature.
domain: Feature
range: Feature

direction
type: DatatypeProperty
type: FunctionalProperty
comment: Indicates how values of this Feature are determined or used (as specified for the FeatureDirectionKind).
domain: Feature
range: FeatureDirectionKind

endOwningType
type: ObjectProperty
comment: The Type that is related to this Feature by an EndFeatureMembership in which the Feature is an ownedMemberFeature.
domain: Feature
range: Type
inverse of: ownedEndFeature

featureTarget
type: FunctionalProperty
type: ObjectProperty
comment: The last of the chainingFeatures of this Feature, if it has any. Otherwise, this Feature itself.
domain: Feature
range: Feature

featuringType
is ordered: true
type: ObjectProperty
comment: Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature.
domain: Feature
range: Type

isComposite
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the Feature is a composite feature of its featuringType. If so, the values of the Feature cannot exist after its featuring instance no longer does.
domain: Feature
range: boolean

isDerived
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the values of this Feature can always be computed from the values of other Features.
domain: Feature
range: boolean

isEnd
type: DatatypeProperty
type: FunctionalProperty
comment: Whether or not the this Feature is an end Feature, requiring a different interpretation of the multiplicity of the Feature. An end Feature is always considered to map each domain instance to a single co-domain instance, whether or not a Multiplicity is given for it. If a Multiplicity is given for an end Feature, rather than giving the co-domain cardinality for the Feature as usual, it specifies a cardinality constraint for navigating across the endFeatures of the featuringType of the end Feature. That is, if a Type has n endFeatures, then the Multiplicity of any one of those end Features constrains the cardinality of the set of values of that Feature when the values of the other n-1 end Features are held fixed.
domain: Feature
range: boolean

isNonunique
type: DatatypeProperty
type: FunctionalProperty
domain: Feature
range: boolean

isOrdered
type: DatatypeProperty
type: FunctionalProperty
comment: Whether an order exists for the values of this Feature or not.
domain: Feature
range: boolean

isPortion
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the values of this Feature are contained in the space and time of instances of the domain of the Feature and represent the same thing as those instances.
domain: Feature
range: boolean

isReadOnly
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the values of this Feature can change over the lifetime of an instance of the domain.
domain: Feature
range: boolean

isUnique
type: DatatypeProperty
type: FunctionalProperty
comment: Whether or not values for this Feature must have no duplicates or not.
domain: Feature
range: boolean

ownedFeatureChaining
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Feature that are FeatureChainings, for which the Feature will be the featureChained.
domain: Feature
range: FeatureChaining
inverse of: featureChained

ownedFeatureInverting
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Feature that are FeatureInvertings and for which the Feature is the featureInverted.
domain: Feature
range: FeatureInverting
inverse of: owningFeature

ownedRedefinition
type: ObjectProperty
comment: The ownedSubsettings of this Feature that are Redefinitions, for which the Feature is the redefiningFeature.
domain: Feature
range: Redefinition
sub property of: ownedSubsetting

ownedReferenceSubsetting
type: InverseFunctionalProperty
type: ObjectProperty
comment: The one ownedSubsetting of this Feature, if any, that is a ReferenceSubsetting, for which the Feature is the referencingFeature.
domain: Feature
range: ReferenceSubsetting
inverse of: referencingFeature

ownedSubsetting
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedSpecializations of this Feature that are Subsettings, for which the Feature is the subsettingFeature.
domain: Feature
range: Subsetting
inverse of: owningFeature

ownedTypeFeaturing
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Feature that are TypeFeaturings and for which the Feature is the featureOfType.
domain: Feature
range: TypeFeaturing
inverse of: owningFeatureOfType

ownedTyping
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedSpecializations of this Feature that are FeatureTypings, for which the Feature is the typedFeature.
domain: Feature
range: FeatureTyping
inverse of: owningFeature

owningFeatureMembership
type: InverseFunctionalProperty
type: ObjectProperty
comment: The FeatureMembership that owns this Feature as an ownedMemberFeature, determining its owningType.
domain: Feature
range: FeatureMembership
inverse of: ownedMemberFeature

owningType
type: ObjectProperty
comment: The Type that is the owningType of the owningFeatureMembership of this Feature.
domain: Feature
range: Type
sub property of: featuringType
inverse of: ownedFeature

type
is ordered: true
type: ObjectProperty
comment: Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature.
domain: Feature
range: Type

Featuring
type: Class
comment: Featuring is a Relationship between a Type and a Feature that is featured by that Type. It asserts that every instance in the domain of the feature must be classified by the type. Featuring is abstract and does not commit to which of feature or type are the source or target of the Relationship. This commitment is made in the subclasses of Featuring, TypeFeaturing and FeatureMembership, which have opposite directions.
subclass of: Restriction
  cardinality: 1
  on property: feature
subclass of: Restriction
  cardinality: 1
  on property: type
subclass of: Relationship

feature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is featured by the featuringType.
domain: Featuring
range: Feature
sub property of: relatedElement

type
type: FunctionalProperty
type: ObjectProperty
comment: The Type that features the featureOfType.
domain: Featuring
range: Type
sub property of: relatedElement

FlowConnectionDefinition
type: Class
comment: A FlowConnectionDefinition is a ConnectionDefinition and ActionDefinition that is also an Interaction representing flows between Usages. specializesFromLibrary('Connections::MessageConnection')
subclass of: ActionDefinition
subclass of: ConnectionDefinition
subclass of: Interaction

FlowConnectionUsage
type: Class
comment: A FlowConnectionUsage is a ConnectionUsage that is also an ItemFlow. if ownedEndFeatures->isEmpty() then specializesFromLibrary('Connections::messageConnections') else specializesFromLibrary('Connections::flowConnections') endif
subclass of: ActionUsage
subclass of: ConnectionUsage
subclass of: ItemFlow

flowConnectionDefinition
is ordered: true
type: ObjectProperty
comment: The Interactions that are the types of this FlowConnectionUsage. Nominally, these are FlowConnectionDefinitions, but other kinds of Kernel Interactions are also allowed, to permit use of Interactions from the Kernel Model Libraries.
domain: FlowConnectionUsage
range: Interaction
sub property of: actionDefinition
sub property of: connectionDefinition
sub property of: interaction

ForLoopActionUsage
type: Class
comment: A ForLoopActionUsage is a LoopActionUsage that specifies that its bodyAction ActionUsage should be performed once for each value, in order, from the sequence of values obtained as the result of the seqArgument Expression, with the loopVariable set to the value for each iteration. seqArgument = argument(1) isSubactionUsage() implies specializesFromLibrary('Actions::Action::forLoops') loopVariable <> null and loopVariable.redefinesFromLibrary('Actions::ForLoopAction::var') specializesFromLibrary('Actions::forLoopActions') loopVariable = if ownedFeature->isEmpty() or not ownedFeature->first().oclIsKindOf(ReferenceUsage) then null else ownedFeature->first().oclAsType(ReferenceUsage) endif ownedFeature->notEmpty() and ownedFeature->at(1).oclIsKindOf(ReferenceUsage) inputParameters()->size() = 2
subclass of: Restriction
  cardinality: 1
  on property: loopVariable
subclass of: Restriction
  cardinality: 1
  on property: seqArgument
subclass of: LoopActionUsage

loopVariable
type: FunctionalProperty
type: ObjectProperty
comment: The ownedFeature of this <co>ForLoopActionUsage that acts as the loop variable, which is assigned the successive values of the input sequence on each iteration. It is the ownedFeature that redefines ForLoopAction::var.
domain: ForLoopActionUsage
range: ReferenceUsage

seqArgument
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result provides the sequence of values to which the loopVariable is set for each iterative performance of the bodyAction. It is the Expression whose result is bound to the seq input parameter of this ForLoopActionUsage.
domain: ForLoopActionUsage
range: Expression

ForkNode
type: Class
comment: A ForkNode is a ControlNode that must be followed by successor Actions as given by all its outgoing Successions. targetConnector->selectByKind(Succession)->size() <= 1 specializesFromLibrary('Actions::Action::forks')
subclass of: ControlNode

FramedConcernMembership
type: Class
comment: A FramedConcernMembership is a RequirementConstraintMembership for a framed ConcernUsage of a RequirementDefinition or RequirementUsage. kind = RequirementConstraintKind::requirement
subclass of: Restriction
  cardinality: 1
  on property: ownedConcern
subclass of: Restriction
  cardinality: 1
  on property: referencedConcern
subclass of: RequirementConstraintMembership

ownedConcern
type: FunctionalProperty
type: ObjectProperty
comment: The ConcernUsage that is the ownedConstraint of this FramedConcernMembership.
domain: FramedConcernMembership
range: ConcernUsage
sub property of: ownedConstraint

referencedConcern
type: FunctionalProperty
type: ObjectProperty
comment: The ConcernUsage that is referenced through this FramedConcernMembership. It is the referencedConstraint of the FramedConcernMembership considered as a RequirementConstraintMembership, which must be a ConcernUsage.
domain: FramedConcernMembership
range: ConcernUsage
sub property of: referencedConstraint

Function
type: Class
comment: A Function is a Behavior that has an out parameter that is identified as its result. A Function represents the performance of a calculation that produces the values of its result parameter. This calculation may be decomposed into Expressions that are steps of the Function. ownedMembership.selectByKind(ResultExpressionMembership)-> forAll(mem | ownedFeature.selectByKind(BindingConnector)-> exists(binding | binding.relatedFeature->includes(result) and binding.relatedFeature->includes(mem.ownedResultExpression.result))) specializesFromLibrary('Performances::Evaluation') result = let resultParams : Sequence(Feature) = ownedFeatureMemberships-> selectByKind(ReturnParameterMembership). ownedParameterMember in if resultParams->notEmpty() then resultParams->first() else null endif ownedFeatureMembership-> selectByKind(ReturnParameterMembership)-> size() <= 1 membership->selectByKind(ResultExpressionMembership)->size() <= 1
subclass of: Restriction
  cardinality: 1
  on property: result
subclass of: Restriction
  cardinality: 1
  on property: isModelLevelEvaluable
subclass of: Behavior

expression
type: ObjectProperty
comment: The Expressions that are steps in the calculation of the result of this Function. The set of expressions that represent computational steps or parts of a system of equations within the Function.
domain: Function
range: Expression
sub property of: step

isModelLevelEvaluable
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false. Note: See the specification of the KerML concrete syntax notation for Expressions for an identification of which library Functions are model-level evaluable.
domain: Function
range: boolean

result
type: FunctionalProperty
type: ObjectProperty
comment: The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership. The object or value that is the result of evaluating the Function.
domain: Function
range: Feature
sub property of: parameter
sub property of: output

IfActionUsage
type: Class
comment: An IfActionUsage is an ActionUsage that specifies that the thenAction ActionUsage should be performed if the result of the ifArgument Expression is true. It may also optionally specify an elseAction ActionUsage that is performed if the result of the ifArgument is false. thenAction = let parameter : Feature = inputParameter(2) in if parameter <> null and parameter.oclIsKindOf(ActionUsage) then parameter.oclAsType(ActionUsage) else null endif isSubactionUsage() implies specializesFromLibrary('Actions::Action::ifSubactions') if elseAction = null then specializesFromLibrary('Actions::ifThenActions') else specializesFromLibrary('Actions::ifThenElseActions') endif ifArgument = let parameter : Feature = inputParameter(1) in if parameter <> null and parameter.oclIsKindOf(Expression) then parameter.oclAsType(Expression) else null endif elseAction = let parameter : Feature = inputParameter(3) in if parameter <> null and parameter.oclIsKindOf(ActionUsage) then parameter.oclAsType(ActionUsage) else null endif inputParameters()->size() >= 2
subclass of: Restriction
  cardinality: 1
  on property: ifArgument
subclass of: Restriction
  cardinality: 1
  on property: thenAction
subclass of: ActionUsage

elseAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage that is to be performed if the result of the ifArgument is false. It is the (optional) third parameter of the IfActionUsage.
domain: IfActionUsage
range: ActionUsage

ifArgument
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result determines whether the thenAction or (optionally) the elseAction is performed. It is the first parameter of the IfActionUsage.
domain: IfActionUsage
range: Expression

thenAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage that is to be performed if the result of the ifArgument is true. It is the second parameter of the IfActionUsage.
domain: IfActionUsage
range: ActionUsage

Import
type: Class
comment: An Import is an Relationship between its importOwningNamespace and either a Membership (for a MembershipImport) or another Namespace (for a NamespaceImport), which determines a set of Memberships that become importedMemberships of the importOwningNamespace. If isImportAll = false (the default), then only public Memberships are considered "visible". If isImportAll = true, then all Memberships are considered "visible", regardless of their declared visibility. If isRecursive = true, then visible Memberships are also recursively imported from owned sub-Namespaces. importOwningNamespace.owningNamespace = null implies visibility = VisibilityKind::private
subclass of: Restriction
  cardinality: 1
  on property: importOwningNamespace
subclass of: Restriction
  cardinality: 1
  on property: importedElement
subclass of: Restriction
  cardinality: 1
  on property: isImportAll
subclass of: Restriction
  cardinality: 1
  on property: isRecursive
subclass of: Restriction
  cardinality: 1
  on property: visibility
subclass of: Relationship

importOwningNamespace
type: FunctionalProperty
type: ObjectProperty
comment: The Namespace into which Memberships are imported by this Import, which must be the owningRelatedElement of the Import.
domain: Import
range: Namespace
sub property of: owningRelatedElement
sub property of: source

importedElement
type: FunctionalProperty
type: ObjectProperty
comment: The effectively imported Element for this Import. For a MembershipImport, this is the memberElement of the importedMembership. For a NamespaceImport, it is the importedNamespace.
domain: Import
range: Element

isImportAll
type: DatatypeProperty
type: FunctionalProperty
comment: Whether to import memberships without regard to declared visibility.
domain: Import
range: boolean

isRecursive
type: DatatypeProperty
type: FunctionalProperty
comment: Whether to recursively import Memberships from visible, owned sub-Namespaces.
domain: Import
range: boolean

visibility
type: DatatypeProperty
type: FunctionalProperty
comment: The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private.
domain: Import
range: VisibilityKind

IncludeUseCaseUsage
type: Class
comment: An IncludeUseCaseUsage is a UseCaseUsage that represents the inclusion of a UseCaseUsage by a UseCaseDefinition or UseCaseUsage. Unless it is the IncludeUseCaseUsage itself, the UseCaseUsage to be included is related to the includedUseCase by a ReferenceSubsetting Relationship. An IncludeUseCaseUsage is also a PerformActionUsage, with its useCaseIncluded as the performedAction. owningType <> null and (owningType.oclIsKindOf(UseCaseDefinition) or owningType.oclIsKindOf(UseCaseUsage) implies specializesFromLibrary('UseCases::UseCase::includedUseCases') ownedReferenceSubsetting <> null implies ownedReferenceSubsetting.referencedFeature.oclIsKindOf(UseCaseUsage)
subclass of: Restriction
  cardinality: 1
  on property: useCaseIncluded
subclass of: PerformActionUsage
subclass of: UseCaseUsage

useCaseIncluded
type: FunctionalProperty
type: ObjectProperty
comment: The UseCaseUsage to be included by this IncludeUseCaseUsage. It is the performedAction of the IncludeUseCaseUsage considered as a PerformActionUsage, which must be a UseCaseUsage.
domain: IncludeUseCaseUsage
range: UseCaseUsage
sub property of: performedAction

Interaction
type: Class
comment: An Interaction is a Behavior that is also an Association, providing a context for multiple objects that have behaviors that impact one another.
subclass of: Association
subclass of: Behavior

InterfaceDefinition
type: Class
comment: An InterfaceDefinition is a ConnectionDefinition all of whose ends are PortUsages, defining an interface between elements that interact through such ports. specializesFromLibrary('Interfaces::Interface') ownedEndFeature->size() = 2 implies specializesFromLibrary('Interfaces::BinaryInterface')
subclass of: ConnectionDefinition

interfaceEnd
is ordered: true
type: ObjectProperty
comment: The PortUsages that are the connectionEnds of this InterfaceDefinition.
domain: InterfaceDefinition
range: PortUsage
sub property of: connectionEnd

InterfaceUsage
type: Class
comment: An InterfaceUsage is a Usage of an InterfaceDefinition to represent an interface connecting parts of a system through specific ports. ownedEndFeature->size() = 2 implies specializesFromLibrary('Interfaces::binaryInterfaces') specializesFromLibrary('Interfaces::interfaces')
subclass of: ConnectionUsage

interfaceDefinition
type: ObjectProperty
comment: The InterfaceDefinitions that type this InterfaceUsage.
domain: InterfaceUsage
range: InterfaceDefinition
sub property of: connectionDefinition

Intersecting
type: Class
comment: Intersecting is a Relationship that makes its intersectingType one of the intersectingTypes of its typeIntersected.
subclass of: Restriction
  cardinality: 1
  on property: intersectingType
subclass of: Restriction
  cardinality: 1
  on property: typeIntersected
subclass of: Relationship

intersectingType
type: FunctionalProperty
type: ObjectProperty
comment: Type that partly determines interpretations of typeIntersected, as described in Type::intersectingType.
domain: Intersecting
range: Type
sub property of: target

typeIntersected
type: FunctionalProperty
type: ObjectProperty
comment: Type with interpretations partly determined by intersectingType, as described in Type::intersectingType.
domain: Intersecting
range: Type
sub property of: owningRelatedElement
sub property of: source

Invariant
type: Class
comment: An Invariant is a BooleanExpression that is asserted to have a specific Boolean result value. If isNegated = false, then the result is asserted to be true. If isNegated = true, then the result is asserted to be false. if isNegated then specializesFromLibrary('Performances::falseEvaluations') else specializesFromLibrary('Performances::trueEvaluations') endif
subclass of: Restriction
  cardinality: 1
  on property: isNegated
subclass of: BooleanExpression

isNegated
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Invariant is asserted to be false rather than true.
domain: Invariant
range: boolean

InvocationExpression
type: Class
comment: An InvocationExpression is an Expression each of whose input parameters are bound to the result of an argument Expression. not ownedTyping->exists(oclIsKindOf(Function)) and not ownedSubsetting->reject(isImplied).subsettedFeature.type-> exists(oclIsKindOf(Function)) implies ownedFeature.selectByKind(BindingConnector)->exists( relatedFeature->includes(self) and relatedFeature->includes(result)) TBD ownedFeature-> select(direction = _'in').valuation-> select(v | v <> null).value let features : Set(Feature) = type.feature->asSet() in input->forAll(inp | inp.ownedRedefinition.redefinedFeature-> intersection(features)->size() = 1) let features : Set(Feature) = type.feature->asSet() in input->forAll(inp1 | input->forAll(inp2 | inp1 <> inp2 implies inp1.ownedRedefinition.redefinedFeature-> intersection(inp2.ownedRedefinition.redefinedFeature)-> intersection(features)->isEmpty()))
subclass of: Expression

argument
is ordered: true
type: ObjectProperty
comment: The value Expressions of the FeatureValues of the owned input parameters of the InvocationExpression.
domain: InvocationExpression
range: Expression
sub property of: ownedFeature

operand
is ordered: true
type: ObjectProperty
domain: InvocationExpression
range: Expression

ItemDefinition
type: Class
comment: An ItemDefinition is an OccurrenceDefinition of the Structure of things that may themselves be systems or parts of systems, but may also be things that are acted on by a system or parts of a system, but which do not necessarily perform actions themselves. This includes items that can be exchanged between parts of a system, such as water or electrical signals. specializesFromLibrary('Items::Item')
subclass of: OccurrenceDefinition
subclass of: Structure

ItemFeature
type: Class
comment: An ItemFeature is the ownedFeature of an ItemFlow that identifies the things carried by the kinds of transfers that are instances of the ItemFlow. ownedRedefinition.redefinedFeature-> redefinesFromLibrary('Transfers::Transfer::item')
subclass of: Feature

ItemFlow
type: Class
comment: An ItemFlow is a Step that represents the transfer of objects or data values from one Feature to another. ItemFlows can take non-zero time to complete. if itemFlowEnds->isEmpty() then specializesFromLibrary('Transfers::transfers') else specializesFromLibrary('Transfers::flowTransfers') endif itemType = if itemFeature = null then Sequence{} else itemFeature.type endif sourceOutputFeature = if connectorEnd->isEmpty() or connectorEnd.ownedFeature->isEmpty() then null else connectorEnd.ownedFeature->first() endif targetInputFeature = if connectorEnd->size() < 2 or connectorEnd->at(2).ownedFeature->isEmpty() then null else connectorEnd->at(2).ownedFeature->first() endif itemFlowEnd = connectorEnd->selectByKind(ItemFlowEnd) itemFeature = let itemFeatures : Sequence(ItemFeature) = ownedFeature->selectByKind(ItemFeature) in if itemFeatures->isEmpty() then null else itemFeatures->first() endif ownedFeature->selectByKind(ItemFeature)->size() <= 1
subclass of: Restriction
  max cardinality: 2
  on property: itemFlowEnd
subclass of: Connector
subclass of: Step

ItemFlowEnd
type: Class
comment: An ItemFlowEnd is a Feature that is one of the connectorEnds giving the source or target of an ItemFlow. For ItemFlows typed by FlowTransfer or its specializations, ItemFlowEnds must have exactly one ownedFeature, which redefines Transfer::source::sourceOutput or Transfer::target::targetInput and redefines the corresponding feature of the relatedElement for its end. isEnd ownedFeature->size() = 1 owningType <> null and owningType.oclIsKindOf(ItemFlow)
subclass of: Feature

interaction
is ordered: true
type: ObjectProperty
comment: The Interactions that type this ItemFlow. Interactions are both Associations and Behaviors, which can type Connectors and Steps, respectively.
domain: ItemFlow
range: Interaction
sub property of: association
sub property of: behavior

itemFeature
type: FunctionalProperty
type: ObjectProperty
comment: The ownedFeature of the ItemFlow that is an ItemFeature (if any).
domain: ItemFlow
range: ItemFeature
sub property of: ownedFeature

itemFlowEnd
is ordered: true
type: ObjectProperty
comment: The connectorEnds of this ItemFlow that are ItemFlowEnds.
domain: ItemFlow
range: ItemFlowEnd
sub property of: connectorEnd

itemType
is ordered: true
type: ObjectProperty
comment: The type of values transferred, which is the type of the itemFeature of the ItemFlow.
domain: ItemFlow
range: Classifier

sourceOutputFeature
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that provides the items carried by the ItemFlow. It must be an owned output of the source of the ItemFlow.
domain: ItemFlow
range: Feature

targetInputFeature
is ordered: true
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that receives the values carried by the ItemFlow. It must be an owned output of the target participant of the ItemFlow.
domain: ItemFlow
range: Feature

ItemUsage
type: Class
comment: An ItemUsage is a ItemUsage whose definition is a Structure. Nominally, if the definition is an ItemDefinition, an ItemUsage is a ItemUsage of that ItemDefinition within a system. However, other kinds of Kernel Structures are also allowed, to permit use of Structures from the Kernel Model Libraries. itemDefinition = occurrenceDefinition->selectByKind(ItemDefinition) specializesFromLibrary('Items::items') isComposite and owningType <> null and (owningType.oclIsKindOf(ItemDefinition) or owningType.oclIsKindOf(ItemUsage)) implies specializesFromLibrary('Items::Item::subitem')
subclass of: OccurrenceUsage

itemDefinition
is ordered: true
type: ObjectProperty
comment: The Structures that are the definitions of this ItemUsage. Nominally, these are ItemDefinitions, but other kinds of Kernel Structures are also allowed, to permit use of Structures from the Kernel Library.
domain: ItemUsage
range: Structure
sub property of: occurrenceDefinition

JoinNode
type: Class
comment: A JoinNode is a ControlNode that waits for the completion of all the predecessor Actions given by incoming Successions. sourceConnector->selectByKind(Succession)->size() <= 1 specializesFromLibrary('Actions::Action::join')
subclass of: ControlNode

LibraryPackage
type: Class
comment: A LibraryPackage is a Package that is the container for a model library. A LibraryPackage is itself a library Element as are all Elements that are directly or indirectly contained in it.
subclass of: Restriction
  cardinality: 1
  on property: isStandard
subclass of: Package

isStandard
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this LibraryPackage contains a standard library model. This should only be set to true for LibraryPackages in the standard Kernel Model Libraries or in normative model libraries for a language built on KerML.
domain: LibraryPackage
range: boolean

LifeClass
type: Class
comment: A LifeClass is a Class that specializes both the Class Occurrences::Life from the Kernel Semantic Library and a single OccurrenceDefinition, and has a multiplicity of 0..1. This constrains the OccurrenceDefinition being specialized to have at most one instance that is a complete Life. specializesFromLibrary('Occurrences::Life') multiplicity <> null and multiplicity.specializesFromLibrary('Base::zeroOrOne') specializes(individualDefinition) isSufficient
subclass of: Class

LiteralBoolean
type: Class
comment: LiteralBoolean is a LiteralExpression that provides a Boolean value as a result. Its result parameter must have type Boolean. specializesFromLibrary('Performances::literalBooleanEvaluations')
subclass of: Restriction
  cardinality: 1
  on property: value
subclass of: LiteralExpression

value
type: DatatypeProperty
type: FunctionalProperty
comment: The Boolean value that is the result of evaluating this LiteralBoolean. The Boolean value that is the result of evaluating this Expression.
domain: LiteralBoolean
range: boolean

LiteralExpression
type: Class
comment: A LiteralExpression is an Expression that provides a basic DataValue as a result. isModelLevelEvaluable = true specializesFromLibrary('Performances::literalEvaluations')
subclass of: Expression

LiteralInfinity
type: Class
comment: A LiteralInfinity is a LiteralExpression that provides the positive infinity value (*). It's result must have the type Positive. specializesFromLibrary('Performances::literalIntegerEvaluations')
subclass of: LiteralExpression

LiteralInteger
type: Class
comment: A LiteralInteger is a LiteralExpression that provides an Integer value as a result. Its result parameter must have the type Integer. specializesFromLibrary('Performances::literalIntegerEvaluations')
subclass of: Restriction
  cardinality: 1
  on property: value
subclass of: LiteralExpression

value
type: DatatypeProperty
type: FunctionalProperty
comment: The Integer value that is the result of evaluating this LiteralInteger. The Integer value that is the result of evaluating this Expression.
domain: LiteralInteger
range: int

LiteralRational
type: Class
comment: A LiteralRational is a LiteralExpression that provides a Rational value as a result. Its result parameter must have the type Rational. specializesFromLibrary('Performances::literalRationalEvaluations')
subclass of: Restriction
  cardinality: 1
  on property: value
subclass of: LiteralExpression

value
type: DatatypeProperty
type: FunctionalProperty
comment: The value whose rational approximation is the result of evaluating this LiteralRational. The Real value that is the result of evaluating this Expression.
domain: LiteralRational
range: real

LiteralString
type: Class
comment: A LiteralString is a LiteralExpression that provides a String value as a result. Its result parameter must have the type String. specializesFromLibrary('Performances::literalStringEvaluations')
subclass of: Restriction
  cardinality: 1
  on property: value
subclass of: LiteralExpression

value
type: DatatypeProperty
type: FunctionalProperty
comment: The String value that is the result of evaluating this LiteralString. The String value that is the result of evaluating this Expression.
domain: LiteralString
range: string

LoopActionUsage
type: Class
comment: A LoopActionUsage is an ActionUsage that specifies that its bodyAction should be performed repeatedly. Its subclasses WhileLoopActionUsage and ForLoopActionUsage provide different ways to determine how many times the bodyAction should be performed. bodyAction = let parameter : Feature = inputParameter(2) in if parameter <> null and parameter.oclIsKindOf(Action) then parameter.oclAsType(Action) else null endif
subclass of: Restriction
  cardinality: 1
  on property: bodyAction
subclass of: ActionUsage

bodyAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage to be performed repeatedly by the LoopActionUsage. It is the second parameter of the LoopActionUsage.
domain: LoopActionUsage
range: ActionUsage

Membership
type: Class
comment: A Membership is a Relationship between a Namespace and an Element that indicates the Element is a member of (i.e., is contained in) the Namespace. Any memberNames specify how the memberElement is identified in the Namespace and the visibility specifies whether or not the memberElement is publicly visible from outside the Namespace. If a Membership is an OwningMembership, then it owns its memberElement, which becomes an ownedMember of the membershipOwningNamespace. Otherwise, the memberNames of a Membership are effectively aliases within the membershipOwningNamespace for an Element with a separate OwningMembership in the same or a different Namespace. memberElementId = memberElement.elementId
subclass of: Restriction
  cardinality: 1
  on property: memberElement
subclass of: Restriction
  cardinality: 1
  on property: membershipOwningNamespace
subclass of: Restriction
  cardinality: 1
  on property: memberElementId
subclass of: Restriction
  cardinality: 1
  on property: visibility
subclass of: Relationship

MembershipExpose
type: Class
comment: A MembershipExpose is an Expose <code.Relationship that exposes a specific importedMembership and, if isRecursive = true, additional Memberships recursively.
subclass of: Expose
subclass of: MembershipImport

MembershipImport
type: Class
comment: A MembershipImport is an Import that imports its importedMembership into the importOwningNamespace. If isRecursive = true and the memberElement of the importedMembership is a Namespace, then the equivalent of a recursive NamespaceImport is also performed on that Namespace. importedElement = importedMembership.memberElement
subclass of: Restriction
  cardinality: 1
  on property: importedMembership
subclass of: Import

importedMembership
type: FunctionalProperty
type: ObjectProperty
comment: The Membership to be imported.
domain: MembershipImport
range: Membership
sub property of: target

memberElement
type: FunctionalProperty
type: ObjectProperty
comment: The Element that becomes a member of the membershipOwningNamespace due to this Membership.
domain: Membership
range: Element
sub property of: target

memberElementId
type: DatatypeProperty
type: FunctionalProperty
comment: The elementId of the memberElement.
domain: Membership
range: string

memberName
type: DatatypeProperty
type: FunctionalProperty
comment: The name of the memberElement relative to the membershipOwningNamespace.
domain: Membership
range: string

memberShortName
type: DatatypeProperty
type: FunctionalProperty
comment: The short name of the memberElement relative to the membershipOwningNamespace.
domain: Membership
range: string

membershipOwningNamespace
type: FunctionalProperty
type: ObjectProperty
comment: The Namespace of which the memberElement becomes a member due to this Membership.
domain: Membership
range: Namespace
sub property of: owningRelatedElement
sub property of: source

visibility
type: DatatypeProperty
type: FunctionalProperty
comment: Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace.
domain: Membership
range: VisibilityKind

MergeNode
type: Class
comment: A MergeNode is a ControlNode that asserts the merging of its incoming Successions. A MergeNode may have at most one outgoing Successions. sourceConnector->selectAsKind(Succession)->size() <= 1 targetConnector->selectByKind(Succession)-> collect(connectorEnd->at(1))-> forAll(sourceMult | multiplicityHasBounds(sourceMult, 0, 1)) targetConnector->selectByKind(Succession)-> forAll(subsetsChain(self, resolveGlobal('ControlPerformances::MergePerformance::incomingHBLink'))) specializesFromLibrary('Actions::Action::merges')
subclass of: ControlNode

Metaclass
type: Class
comment: A Metaclass is a Structure used to type MetadataFeatures. specializesFromLibrary('Metaobjects::Metaobject')
subclass of: Structure

MetadataAccessExpression
type: Class
comment: A MetadataAccessExpression is an Expression whose result is a sequence of instances of Metaclasses representing all the MetadataFeature annotations of the referencedElement. In addition, the sequence includes an instance of the reflective Metaclass corresponding to the MOF class of the referencedElement, with values for all the abstract syntax properties of the referencedElement. specializesFromLibrary('Performances::metadataAccessEvaluations')
subclass of: Restriction
  cardinality: 1
  on property: referencedElement
subclass of: Expression

referencedElement
type: FunctionalProperty
type: ObjectProperty
comment: The Element whose metadata is being accessed.
domain: MetadataAccessExpression
range: Element

MetadataDefinition
type: Class
comment: A MetadataDefinition is an ItemDefinition that is also a Metaclass. specializesFromLibrary('Metadata::MetadataItem')
subclass of: ItemDefinition
subclass of: Metaclass

MetadataFeature
type: Class
comment: A MetadataFeature is a Feature that is an AnnotatingElement used to annotate another Element with metadata. It is typed by a Metaclass. All its ownedFeatures must redefine features of its metaclass and any feature bindings must be model-level evaluable. specializesFromLibrary('Metaobjects::metaobjects') isSemantic() implies let annotatedTypes : Sequence(Type) = annotatedElement->selectAsKind(Type) in let baseTypes : Sequence(MetadataFeature) = evaluateFeature(resolveGlobal( 'Metaobjects::SemanticMetadata::baseType'). memberElement. oclAsType(Feature))-> selectAsKind(MetadataFeature) in annotatedTypes->notEmpty() and baseTypes()->notEmpty() and baseTypes()->first().isSyntactic() implies let annotatedType : Type = annotatedTypes->first() in let baseType : Element = baseTypes->first().syntaxElement() in if annotatedType.oclIsKindOf(Classifier) and baseType.oclIsKindOf(Feature) then baseType.oclAsType(Feature).type-> forAll(t | annotatedType.specializes(t)) else if baseType.oclIsKindOf(Type) then annotatedType.specializes(baseType.oclAsType(Type)) else true endif not metaclass.isAbstract let baseAnnotatedElementFeature : Feature = resolveGlobal('Metaobjects::Metaobject::annotatedElement').memberElement. oclAsType(Feature) in let annotatedElementFeatures : OrderedSet(Feature) = feature-> select(specializes(baseAnnotatedElementFeature))-> excluding(baseAnnotatedElementFeature) in annotatedElementFeatures->notEmpty() implies let annotatedElementTypes : Set(Feature) = annotatedElementFeatures.typing.type->asSet() in let metaclasses : Set(Metaclass) = annotatedElement.oclType().qualifiedName->collect(qn | resolveGlobal(qn).memberElement.oclAsType(Metaclass)) in metaclasses->forAll(m | annotatedElementTypes->exists(t | m.specializes(t))) ownedFeature->closure(ownedFeature)->forAll(f | f.declaredName = null and f.declaredShortName = null and f.valuation <> null implies f.valuation.value.isModelLevelEvaluable and f.redefinition.redefinedFeature->size() = 1) metaclass = let meta…
subclass of: AnnotatingElement
subclass of: Feature

metaclass
type: FunctionalProperty
type: ObjectProperty
comment: The type of this MetadataFeature, which must be a Metaclass.
domain: MetadataFeature
range: Metaclass
sub property of: type

MetadataUsage
type: Class
comment: A MetadataUsage is a Usage and a MetadataFeature, used to annotate other Elements in a system model with metadata. As a MetadataFeature, its type must be a Metaclass, which will nominally be a MetadataDefinition. However, any kernel Metaclass is also allowed, to permit use of Metaclasses from the Kernel Model Libraries. specializesFromLibrary('Metadata::metadataItems')
subclass of: ItemUsage
subclass of: MetadataFeature

metadataDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The MetadataDefinition that is the definition of this MetadataUsage.
domain: MetadataUsage
range: Metaclass
sub property of: itemDefinition
sub property of: metaclass

Multiplicity
type: Class
comment: A Multiplicity is a Feature whose co-domain is a set of natural numbers giving the allowed cardinalities of each typeWithMultiplicity. The cardinality of a Type is defined as follows, depending on whether the Type is a Classifier or Feature. Classifier – The number of basic instances of the Classifier, that is, those instances representing things, which are not instances of any subtypes of the Classifier that are Features. Features – The number of instances with the same featuring instances. In the case of a Feature with a Classifier as its featuringType, this is the number of values of Feature for each basic instance of the Classifier. Note that, for non-unique Features, all duplicate values are included in this count. Multiplicity co-domains (in models) can be specified by Expression that might vary in their results. If the typeWithMultiplicity is a Classifier, the domain of the Multiplicity shall be Base::Anything. If the typeWithMultiplicity is a Feature, the Multiplicity shall have the same domain as the typeWithMultiplicity. if owningType <> null and owningType.oclIsKindOf(Feature) then featuringType = owningType.oclAsType(Feature).featuringType else featuringType->isEmpty() endif specializesFromLibrary('Base::naturals')
subclass of: Feature

MultiplicityRange
type: Class
comment: A MultiplicityRange is a Multiplicity whose value is defined to be the (inclusive) range of natural numbers given by the result of a lowerBound Expression and the result of an upperBound Expression. The result of these Expressions shall be of type Natural. If the result of the upperBound Expression is the unbounded value *, then the specified range includes all natural numbers greater than or equal to the lowerBound value. If no lowerBound Expression, then the default is that the lower bound has the same value as the upper bound, except if the upperBound evaluates to *, in which case the default for the lower bound is 0. bound->forAll(b | b.featuringType = self.featuringType) bound->forAll(b | b.result.specializesFromLibrary('ScalarValues::Integer') and let value : UnlimitedNatural = valueOf(b) in value <> null implies value >= 0 ) lowerBound = let ownedMembers : Sequence(Element) = ownedMembership->selectByKind(OwningMembership).ownedMember in if ownedMembers->size() < 2 or not ownedMembers->first().oclIsKindOf(Expression) then null else ownedMembers->first().oclAsType(Expression) endif upperBound = let ownedMembers : Sequence(Element) = ownedMembership->selectByKind(OwningMembership).ownedMember in if ownedMembers->isEmpty() or not ownedMembers->last().oclIsKindOf(Expression) then null else ownedMembers->last().oclAsType(Expression) endif
subclass of: Restriction
  min cardinality: 1
  on property: bound
subclass of: Restriction
  cardinality: 1
  on property: upperBound
subclass of: Restriction
  max cardinality: 2
  on property: bound
subclass of: Multiplicity

bound
is ordered: true
type: ObjectProperty
comment: The owned Expressions of the MultiplicityRange whose results provide its bounds. These must be the only ownedMembers of the MultiplicityRange.
domain: MultiplicityRange
range: Expression
sub property of: ownedMember

lowerBound
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result provides the lower bound of the MultiplicityRange. If no lowerBound Expression is given, then the lower bound shall have the same value as the upper bound, unless the upper bound is unbounded (*), in which case the lower bound shall be 0.
domain: MultiplicityRange
range: Expression
sub property of: bound

upperBound
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result is the upper bound of the MultiplicityRange.
domain: MultiplicityRange
range: Expression
sub property of: bound

Namespace
type: Class
comment: A Namespace is an Element that contains other Elements, known as its members, via Membership Relationships with those Elements. The members of a Namespace may be owned by the Namespace, aliased in the Namespace, or imported into the Namespace via Import Relationships. A Namespace can provide names for its members via the memberNames and memberShortNames specified by the Memberships in the Namespace. If a Membership specifies a memberName and/or memberShortName, then those are names of the corresponding memberElement relative to the Namespace. For an OwningMembership, the owningMemberName and owningMemberShortName are given by the Element name and shortName. Note that the same Element may be the memberElement of multiple Memberships in a Namespace (though it may be owned at most once), each of which may define a separate alias for the Element relative to the Namespace. membership->forAll(m1 | membership->forAll(m2 | m1 <> m2 implies m1.isDistinguishableFrom(m2))) member = membership.memberElement ownedMember = ownedMembership->selectByKind(OwningMembership).ownedMemberElement importedMembership = importedMemberships(Set{}) ownedImport = ownedRelationship->selectByKind(Import) ownedMembership = ownedRelationship->selectByKind(Membership)
subclass of: Element

NamespaceExpose
type: Class
comment: A NamespaceExpose is an Expose Relationship that exposes the Memberships of a specific importedNamespace and, if isRecursive = true, additional Memberships recursively.
subclass of: Expose
subclass of: NamespaceImport

NamespaceImport
type: Class
comment: A NamespaceImport is an Import that imports Memberships from its importedNamespace into the importOwningNamespace. If isRecursive = false, then only the visible Memberships of the importedNamespace are imported. If isRecursive = true, then, in addition, Memberships are recursively imported from any ownedMembers of the importedNamespace that are Namespaces. importedElement = importedNamespace
subclass of: Restriction
  cardinality: 1
  on property: importedNamespace
subclass of: Import

importedNamespace
type: FunctionalProperty
type: ObjectProperty
comment: The Namespace whose visible Memberships are imported by this NamespaceImport.
domain: NamespaceImport
range: Namespace
sub property of: target

importedMembership
is ordered: true
type: ObjectProperty
comment: The Memberships in this Namespace that result from the ownedImports of this Namespace.
domain: Namespace
range: Membership
sub property of: membership

member
is ordered: true
type: ObjectProperty
comment: The set of all member Elements of this Namespace, which are the memberElements of all memberships of the Namespace.
domain: Namespace
range: Element

membership
is ordered: true
type: ObjectProperty
comment: All Memberships in this Namespace, including (at least) the union of ownedMemberships and importedMemberships.
domain: Namespace
range: Membership

ownedImport
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Namespace that are Imports, for which the Namespace is the importOwningNamespace.
domain: Namespace
range: Import
inverse of: importOwningNamespace

ownedMember
is ordered: true
type: ObjectProperty
comment: The owned members of this Namespace, which are the <cpde>ownedMemberElements of the ownedMemberships of the Namespace.
domain: Namespace
range: Element
sub property of: member

ownedMembership
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Namespace that are Memberships, for which the Namespace is the membershipOwningNamespace.
domain: Namespace
range: Membership
sub property of: membership
inverse of: membershipOwningNamespace

NullExpression
type: Class
comment: A NullExpression is an Expression that results in a null value. specializesFromLibrary('Performances::nullEvaluations')
subclass of: Expression

ObjectiveMembership
type: Class
comment: An ObjectiveMembership is a FeatureMembership that indicates that its ownedObjectiveRequirement is the objective RequirementUsage for its owningType, which must be a CaseDefinition or CaseUsage. owningType.oclIsType(CaseDefinition) or owningType.oclIsType(CaseUsage) ownedObjectiveRequirement.isComposite
subclass of: Restriction
  cardinality: 1
  on property: ownedObjectiveRequirement
subclass of: FeatureMembership

ownedObjectiveRequirement
type: FunctionalProperty
type: ObjectProperty
comment: The RequirementUsage that is the ownedMemberFeature of this RequirementUsage.
domain: ObjectiveMembership
range: RequirementUsage
sub property of: ownedMemberFeature

OccurrenceDefinition
type: Class
comment: An OccurrenceDefinition is a Definition of a Class of individuals that have an independent life over time and potentially an extent over space. This includes both structural things and behaviors that act on such structures. If isIndividual is true, then the OccurrenceDefinition is constrained to represent an individual thing. The instances of such an OccurrenceDefinition include all spatial and temporal portions of the individual being represented, but only one of these can be the complete Life of the individual. All other instances must be portions of the "maximal portion" that is single Life instance, capturing the conception that all of the instances represent one individual with a single "identity". An OccurrenceDefinition must specialize, directly or indirectly, the base Class Occurrence from the Kernel Semantic Library. let n : Integer = ownedMember->selectByKind(LifeClass) in if isIndividual then n = 1 else n = 0 endif lifeClass = let lifeClasses: OrderedSet(LifeClass) = ownedMember->selectByKind(LifeClass) in if lifeClasses->isEmpty() then null else lifeClasses->first() endif
subclass of: Restriction
  cardinality: 1
  on property: isIndividual
subclass of: Class
subclass of: Definition

isIndividual
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this OccurrenceDefinition is constrained to represent single individual.
domain: OccurrenceDefinition
range: boolean

lifeClass
type: FunctionalProperty
type: ObjectProperty
comment: If isIndividual is true, a LifeClass that specializes this OccurrenceDefinition, restricting it to represent an individual.
domain: OccurrenceDefinition
range: LifeClass
sub property of: ownedMember

OccurrenceUsage
type: Class
comment: An OccurrenceUsage is a Usage whose types are all Classes. Nominally, if a type is an OccurrenceDefinition, an OccurrenceUsage is a Usage of that OccurrenceDefinition within a system. However, other types of Kernel Classes are also allowed, to permit use of Classes from the Kernel Model Libraries. individualDefinition = let individualDefinitions : OrderedSet(OccurrenceDefinition) = occurrenceDefinition-> selectByKind(OccurrenceDefinition)-> select(isIndividual) in if individualDefinitions->isEmpty() then null else individualDefinitions->first() endif isIndividual implies individualDefinition <> null specializesFromLibrary('Occurrences::occurrences') isComposite and owningType <> null and (owningType.oclIsKindOf(Class) or owningType.oclIsKindOf(OccurrenceUsage) or owningType.oclIsKindOf(Feature) and owningType.oclAsType(Feature).type-> exists(oclIsKind(Class))) implies specializesFromLibrary('Occurrences::Occurrence::suboccurrences') occurrenceDefinition-> selectByKind(OccurrenceDefinition)-> select(isIndividual).size() <= 1 portionKind <> null implies occurrenceDefinition->forAll(occ | featuringType->exists(specializes(occ)))
subclass of: Restriction
  cardinality: 1
  on property: isIndividual
subclass of: Usage

individualDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The at most one occurrenceDefinition that has isIndividual = true.
domain: OccurrenceUsage
range: OccurrenceDefinition
sub property of: occurrenceDefinition

isIndividual
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition.
domain: OccurrenceUsage
range: boolean

occurrenceDefinition
is ordered: true
type: ObjectProperty
comment: The Classes that are the types of this OccurrenceUsage. Nominally, these are OccurrenceDefinitions, but other kinds of kernel Classes are also allowed, to permit use of Classes from the Kernel Model Libraries.
domain: OccurrenceUsage
range: Class
sub property of: definition

portionKind
type: DatatypeProperty
type: FunctionalProperty
comment: The kind of (temporal) portion of the life of the occurrenceDefinition represented by this OccurrenceUsage, if it is so restricted.
domain: OccurrenceUsage
range: PortionKind

OperatorExpression
type: Class
comment: An OperatorExpression is an InvocationExpression whose function is determined by resolving its operator in the context of one of the standard packages from the Kernel Function Library. let libFunctions : Sequence(Element) = Sequence{'BaseFunctions', 'DataFunctions', 'ControlFunctions'}-> collect(ns | resolveGlobal(ns + "::'" + operator + "'"). memberElement) in libFunctions->includes(function)
subclass of: Restriction
  cardinality: 1
  on property: operator
subclass of: InvocationExpression

operator
type: DatatypeProperty
type: FunctionalProperty
comment: An operator symbol that names a corresponding Function from one of the standard packages from the Kernel Function Library .
domain: OperatorExpression
range: string

OwningMembership
type: Class
comment: An OwningMembership is a Membership that owns its memberElement as a ownedRelatedElement. The ownedMemberElement becomes an ownedMember of the membershipOwningNamespace. ownedMemberName = ownedMemberElement.name ownedMemberShortName = ownedMemberElement.shortName
subclass of: Restriction
  cardinality: 1
  on property: ownedMemberElement
subclass of: Restriction
  cardinality: 1
  on property: ownedMemberElementId
subclass of: Membership

ownedMemberElement
type: FunctionalProperty
type: ObjectProperty
comment: The Element that becomes an ownedMember of the membershipOwningNamespace due to this OwningMembership.
domain: OwningMembership
range: Element
sub property of: memberElement
sub property of: ownedRelatedElement

ownedMemberElementId
type: DatatypeProperty
type: FunctionalProperty
comment: The elementId of the ownedMemberElement.
domain: OwningMembership
range: string
sub property of: memberElementId

ownedMemberName
type: DatatypeProperty
type: FunctionalProperty
comment: The name of the ownedMemberElement.
domain: OwningMembership
range: string
sub property of: memberName

ownedMemberShortName
type: DatatypeProperty
type: FunctionalProperty
comment: The shortName of the ownedMemberElement.
domain: OwningMembership
range: string
sub property of: memberShortName

Package
type: Class
comment: A Package is a Namespace used to group Elements, without any instance-level semantics. It may have one or more model-level evaluable filterCondition Expressions used to filter its importedMemberships. Any imported member must meet all of the filterConditions. filterCondition = ownedMembership-> selectByKind(ElementFilterMembership).condition
subclass of: Namespace

filterCondition
is ordered: true
type: ObjectProperty
comment: The model-level evaluable Boolean-valued Expression used to filter the members of this Package, which are owned by the Package are via ElementFilterMemberships.
domain: Package
range: Expression
sub property of: ownedMember

ParameterMembership
type: Class
comment: A ParameterMembership is a FeatureMembership that identifies its memberFeature as a parameter, which is always owned, and must have a direction. A ParameterMembership must be owned by a Behavior or a Step. ownedMemberParameter.direction = parameterDirection() owningType.oclIsKindOf(Behavior) or owningType.oclIsKindOf(Step)
subclass of: Restriction
  cardinality: 1
  on property: ownedMemberParameter
subclass of: FeatureMembership

ownedMemberParameter
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is identified as a parameter by this ParameterMembership.
domain: ParameterMembership
range: Feature
sub property of: ownedMemberFeature

PartDefinition
type: Class
comment: A PartDefinition is an ItemDefinition of a Class of systems or parts of systems. Note that all parts may be considered items for certain purposes, but not all items are parts that can perform actions within a system. specializesFromLibrary('Parts::Part')
subclass of: ItemDefinition

PartUsage
type: Class
comment: A PartUsage is a usage of a PartDefinition to represent a system or a part of a system. At least one of the itemDefinitions of the PartUsage must be a PartDefinition. A PartUsage must subset, directly or indirectly, the base PartUsage parts from the Systems Model Library. itemDefinition->selectByKind(PartDefinition) partDefinition->notEmpty() specializesFromLibrary('Parts::parts') isComposite and owningType <> null and (owningType.oclIsKindOf(ItemDefinition) or owningType.oclIsKindOf(ItemUsage)) implies specializesFromLibrary('Items::Item::subparts') owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(ActorMembership) implies if owningType.oclIsKindOf(RequirementDefinition) or owningType.oclIsKindOf(RequirementUsage) then specializesFromLibrary('Requirements::RequirementCheck::actors') else specializesFromLibrary('Cases::Case::actors') owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(StakeholderMembership) implies specializesFromLibrary('Requirements::RequirementCheck::stakeholders')
subclass of: ItemUsage

partDefinition
is ordered: true
type: ObjectProperty
comment: The itemDefinitions of this PartUsage that are PartDefinitions.
domain: PartUsage
range: PartDefinition
sub property of: itemDefinition

PerformActionUsage
type: Class
comment: A PerformActionUsage is an ActionUsage that represents the performance of an ActionUsage. Unless it is the PerformActionUsage itself, the ActionUsage to be performed is related to the PerformActionUsage by a ReferenceSubsetting relationship. A PerformActionUsage is also an EventOccurrenceUsage, with its performedAction as the eventOccurrence. ownedReferenceSubsetting <> null implies ownedReferenceSubsetting.referencedFeature.oclIsKindOf(ActionUsage) owningType <> null and (owningType.oclIsKindOf(PartDefinition) or owningType.oclIsKindOf(PartUsage)) implies specializesFromLibrary('Parts::Part::performedActions')
subclass of: Restriction
  cardinality: 1
  on property: performedAction
subclass of: ActionUsage
subclass of: EventOccurrenceUsage

performedAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage to be performed by this PerformedActionUsage. It is the eventOccurrence of the PerformActionUsage considered as an EventOccurrenceUsage, which must be an ActionUsage.
domain: PerformActionUsage
range: ActionUsage
sub property of: eventOccurrence

PortConjugation
type: Class
comment: A PortConjugation is a Conjugation Relationship between a PortDefinition and its corresponding ConjugatedPortDefinition. As a result of this Relationship, the ConjugatedPortDefinition inherits all the features of the original PortDefinition, but input flows of the original PortDefinition become outputs on the ConjugatedPortDefinition and output flows of the original PortDefinition become inputs on the ConjugatedPortDefinition.
subclass of: Restriction
  cardinality: 1
  on property: conjugatedPortDefinition
subclass of: Restriction
  cardinality: 1
  on property: originalPortDefinition
subclass of: Conjugation

conjugatedPortDefinition
type: FunctionalProperty
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ConjugatedPortDefinition that is conjugate to the originalPortDefinition.
domain: PortConjugation
range: ConjugatedPortDefinition
sub property of: owningType

originalPortDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The PortDefinition being conjugated.
domain: PortConjugation
range: PortDefinition
sub property of: originalType

PortDefinition
type: Class
comment: A PortDefinition defines a point at which external entities can connect to and interact with a system or part of a system. Any ownedUsages of a PortDefinition, other than PortUsages, must not be composite. conjugatedPortDefinition = let conjugatedPortDefinitions : OrderedSet(ConjugatedPortDefinition) = ownedMember->selectByKind(ConjugatedPortDefinition) in if conjugatedPortDefinitions->isEmpty() then null else conjugatedPortDefinitions->first() endif ownedUsage-> reject(oclIsKindOf(PortUsage))-> forAll(not isComposite) not oclIsKindOf(ConjugatedPortDefinition) implies ownedMember-> selectByKind(ConjugatedPortDefinition)-> size() = 1 specializesFromLibrary('Ports::Port')
subclass of: OccurrenceDefinition
subclass of: Structure

conjugatedPortDefinition
type: FunctionalProperty
type: InverseFunctionalProperty
type: ObjectProperty
comment: The <codeConjugatedPortDefinition that is conjugate to this PortDefinition.
domain: PortDefinition
range: ConjugatedPortDefinition
sub property of: ownedMember

PortUsage
type: Class
comment: A PortUsage is a usage of a PortDefinition. A PortUsage itself as well as all its nestedUsages must be referential (non-composite). nestedUsage-> reject(oclIsKindOf(PortUsage))-> forAll(not isComposite) specializesFromLibrary('Ports::ports') isComposite and owningType <> null and (owningType.oclIsKindOf(PortDefinition) or owningType.oclIsKindOf(PortUsage)) implies specializesFromLibrary('Ports::Port::subports') owningType = null or not owningType.oclIsKindOf(PortDefinition) and not owningType.oclIsKindOf(PortUsage) implies isReference
subclass of: OccurrenceUsage

portDefinition
is ordered: true
type: ObjectProperty
comment: The occurrenceDefinitions of this PortUsage, which must all be PortDefinitions.
domain: PortUsage
range: PortDefinition
sub property of: occurrenceDefinition

PortionKind
type: Datatype
comment: PortionKind is an enumeration of the specific kinds of Occurrence portions that can be represented by an OccurrenceUsage.
equivalent class: Datatype
  one of: snapshot
  one of: timeslice

Predicate
type: Class
comment: A Predicate is a Function whose result parameter has type Boolean and multiplicity 1..1. specializesFromLibrary('Performances::BooleanEvaluation')
subclass of: Function

Redefinition
type: Class
comment: Redefinition is a kind of Subsetting that requires the redefinedFeature and the redefiningFeature to have the same values (on each instance of the domain of the redefiningFeature). This means any restrictions on the redefiningFeature, such as type or multiplicity, also apply to the redefinedFeature (on each instance of the domain of the redefiningFeature), and vice versa. The redefinedFeature might have values for instances of the domain of the redefiningFeature, but only as instances of the domain of the redefinedFeature that happen to also be instances of the domain of the redefiningFeature. This is supported by the constraints inherited from Subsetting on the domains of the redefiningFeature and redefinedFeature. However, these constraints are narrowed for Redefinition to require the owningTypes of the redefiningFeature and redefinedFeature to be different and the redefinedFeature to not be inherited into the owningNamespace of the redefiningFeature.This enables the redefiningFeature to have the same name as the redefinedFeature, if desired. let anythingType: Type = redefiningFeature.resolveGlobal('Base::Anything').modelElement.oclAsType(Type) in -- Including "Anything" accounts for implicit featuringType of Features -- with no explicit featuringType. let redefiningFeaturingTypes: Set(Type) = redefiningFeature.featuringTypes->asSet()->including(anythingType) in let redefinedFeaturingTypes: Set(Type) = redefinedFeature.featuringTypes->asSet()->including(anythingType) in redefiningFeaturingTypes <> redefinedFeaturingType featuringType->forAll(t | let direction : FeatureDirectionKind = t.directionOf(redefinedFeature) in ((direction = FeatureDirectionKind::_'in' or direction = FeatureDirectionKind::out) implies redefiningFeature.direction = direction) and (direction = FeatureDirectionKind::inout implies redefiningFeature.direction <> null))
subclass of: Restriction
  cardinality: 1
  on property: redefinedFeature
subclass of: Restriction
  cardinality: 1
  on property: redefiningFeature
subclass of: Subsetting

redefinedFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is redefined by the redefiningFeature of this Redefinition.
domain: Redefinition
range: Feature
sub property of: subsettedFeature

redefiningFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is redefining the redefinedFeature of this Redefinition.
domain: Redefinition
range: Feature
sub property of: subsettingFeature

ReferenceSubsetting
type: Class
comment: ReferenceSubsetting is a kind of Subsetting in which the referencedFeature is syntactically distinguished from other Features subsetted by the referencingFeature. ReferenceSubsetting has the same semantics as Subsetting, but the referenceFeature may have a special purpose relative to the referencingFeature. For instance, ReferenceSubsetting is used to identify the relatedFeatures of a Connector. ReferenceSubsetting is always an ownedRelationship of its referencingFeature. A Feature can have at most one ownedReferenceSubsetting.
subclass of: Restriction
  cardinality: 1
  on property: referencedFeature
subclass of: Restriction
  cardinality: 1
  on property: referencingFeature
subclass of: Subsetting

referencedFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is referenced by the referencingFeature of this ReferenceSubsetting.
domain: ReferenceSubsetting
range: Feature
sub property of: subsettedFeature

referencingFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that owns this ReferenceSubsetting relationship, which is also its subsettingFeature.
domain: ReferenceSubsetting
range: Feature
sub property of: owningFeature

ReferenceUsage
type: Class
comment: A ReferenceUsage is a Usage that specifies a non-compositional (isComposite = false) reference to something. The definition of a ReferenceUsage can be any kind of Classifier, with the default being the top-level Classifier Base::Anything from the Kernel Semantic Library. This allows the specification of a generic reference without distinguishing if the thing referenced is an attribute value, item, action, etc. isReference
subclass of: Usage

Relationship
type: Class
comment: A Relationship is an Element that relates other Element. Some of its relatedElements may be owned, in which case those ownedRelatedElements will be deleted from a model if their owningRelationship is. A Relationship may also be owned by another Element, in which case the ownedRelatedElements of the Relationship are also considered to be transitively owned by the owningRelatedElement of the Relationship. The relatedElements of a Relationship are divided into source and target Elements. The Relationship is considered to be directed from the source to the target Elements. An undirected Relationship may have either all source or all target Elements. A "relationship Element" in the abstract syntax is generically any Element that is an instance of either Relationship or a direct or indirect specialization of Relationship. Any other kind of Element is a "non-relationship Element". It is a convention of that non-relationship Elements are only related via reified relationship Elements. Any meta-associations directly between non-relationship Elements must be derived from underlying reified Relationship. relatedElement = source->union(target)
subclass of: Restriction
  cardinality: 1
  on property: isImplied
subclass of: Element

isImplied
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Relationship was generated by tooling to meet semantic rules, rather than being directly created by a modeler.
domain: Relationship
range: boolean

ownedRelatedElement
is ordered: true
type: ObjectProperty
comment: The relatedElements of this Relationship that are owned by the Relationship.
domain: Relationship
range: Element
sub property of: relatedElement

owningRelatedElement
type: FunctionalProperty
type: ObjectProperty
comment: The relatedElement of this Relationship that owns the Relationship, if any.
domain: Relationship
range: Element
sub property of: relatedElement

relatedElement
is ordered: true
type: ObjectProperty
comment: The Elements that are related by this Relationship, derived as the union of the source and target Elements of the Relationship.
domain: Relationship
range: Element

source
is ordered: true
type: ObjectProperty
comment: The relatedElements</c ode> from which this Relationship is considered to be directed.
domain: Relationship
range: Element
sub property of: relatedElement

target
is ordered: true
type: ObjectProperty
comment: The relatedElements to which this Relationship is considered to be directed.
domain: Relationship
range: Element
sub property of: relatedElement

RenderingDefinition
type: Class
comment: A RenderingDefinition is a PartDefinition that defines a specific rendering of the content of a model view (e.g., symbols, style, layout, etc.). rendering = usages->selectByKind(RenderingUsage) specializesFromLibrary('Views::Rendering')
subclass of: PartDefinition

rendering
is ordered: true
type: ObjectProperty
comment: The usages of a RenderingDefinition that are RenderingUsages.
domain: RenderingDefinition
range: RenderingUsage
sub property of: usage

RenderingUsage
type: Class
comment: A RenderingUsage is the usage of a RenderingDefinition to specify the rendering of a specific model view to produce a physical view artifact. specializesFromLibrary('Views::renderings') owningType <> null and (owningType.oclIsKindOf(RenderingDefinition) or owningType.oclIsKindOf(RenderingUsage)) implies specializesFromLibrary('Views::Rendering::subrenderings') owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(ViewRenderingMembership) implies redefinesFromLibrary('Views::View::viewRendering')
subclass of: PartUsage

renderingDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The RenderingDefinition that is the definition of this RenderingUsage.
domain: RenderingUsage
range: RenderingDefinition
sub property of: partDefinition

RequirementConstraintKind
type: Datatype
comment: A RequirementConstraintKind indicates whether a ConstraintUsage is an assumption or a requirement in a RequirementDefinition or RequirementUsage.
equivalent class: Datatype
  one of: assumption
  one of: requirement

RequirementConstraintMembership
type: Class
comment: A RequirementConstraintMembership is a FeatureMembership for an assumed or required ConstraintUsage of a RequirementDefinition or RequirementUsage. referencedConstraint = let reference : ReferenceSubsetting = ownedConstraint.ownedReferenceSubsetting in if reference = null then ownedConstraint else if not reference.referencedFeature.oclIsKindOf(ConstraintUsage) then null else reference.referencedFeature.oclAsType(ConstraintUsage) endif endif owningType.oclIsKindOf(RequirementDefinition) or owningType.oclIsKindOf(RequirementUsage) ownedConstraint.isComposite
subclass of: Restriction
  cardinality: 1
  on property: ownedConstraint
subclass of: Restriction
  cardinality: 1
  on property: referencedConstraint
subclass of: Restriction
  cardinality: 1
  on property: kind
subclass of: FeatureMembership

kind
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage.
domain: RequirementConstraintMembership
range: RequirementConstraintKind

ownedConstraint
type: FunctionalProperty
type: ObjectProperty
comment: The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership.
domain: RequirementConstraintMembership
range: ConstraintUsage
sub property of: ownedMemberFeature

referencedConstraint
type: FunctionalProperty
type: ObjectProperty
comment: The ConstraintUsage that is referenced through this RequirementConstraintMembership. It is the referencedFeature of the ownedReferenceSubsetting of the ownedConstraint, if there is one, and, otherwise, the ownedConstraint itself.
domain: RequirementConstraintMembership
range: ConstraintUsage

RequirementDefinition
type: Class
comment: A RequirementDefinition is a ConstraintDefinition that defines a requirement used in the context of a specification as a constraint that a valid solution must satisfy. The specification is relative to a specified subject, possibly in collaboration with one or more external actors. text = documentation.body assumedConstraint = ownedFeatureMembership-> selectByKind(RequirementConstraintMembership)-> select(kind = RequirementConstraintKind::assumption). ownedConstraint requiredConstraint = ownedFeatureMembership-> selectByKind(RequirementConstraintMembership)-> select(kind = RequirementConstraintKind::requirement). ownedConstraint subjectParameter = let subjects : OrderedSet(SubjectMembership) = featureMembership->selectByKind(SubjectMembership) in if subjects->isEmpty() then null else subjects->first().ownedSubjectParameter endif framedConcern = featureMembership-> selectByKind(FramedConcernMembership). ownedConcern actorParameter = featureMembership-> selectByKind(ActorMembership). ownedActorParameter stakeholderParameter = featureMembership-> selectByKind(StakholderMembership). ownedStakeholderParameter featureMembership-> selectByKind(SubjectMembership)-> size() <= 1 input->notEmpty() and input->first() = subjectParameter specializesFromLibrary('Requirements::RequirementCheck')
subclass of: Restriction
  cardinality: 1
  on property: subjectParameter
subclass of: ConstraintDefinition

actorParameter
is ordered: true
type: ObjectProperty
comment: The parameters of this RequirementDefinition that represent actors involved in the requirement.
domain: RequirementDefinition
range: PartUsage
sub property of: parameter
sub property of: usage

assumedConstraint
is ordered: true
type: ObjectProperty
comment: The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption.
domain: RequirementDefinition
range: ConstraintUsage
sub property of: ownedFeature

framedConcern
is ordered: true
type: ObjectProperty
comment: The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition.
domain: RequirementDefinition
range: ConcernUsage
sub property of: requiredConstraint

reqId
type: DatatypeProperty
type: FunctionalProperty
comment: An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition.
domain: RequirementDefinition
range: string
sub property of: declaredShortName

requiredConstraint
is ordered: true
type: ObjectProperty
comment: The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement.
domain: RequirementDefinition
range: ConstraintUsage
sub property of: ownedFeature

stakeholderParameter
is ordered: true
type: ObjectProperty
comment: The parameters of this RequirementDefinition that represent stakeholders for th requirement.
domain: RequirementDefinition
range: PartUsage
sub property of: parameter
sub property of: usage

subjectParameter
type: FunctionalProperty
type: ObjectProperty
comment: The parameter of this RequirementDefinition that represents its subject.
domain: RequirementDefinition
range: Usage
sub property of: parameter
sub property of: usage

text
type: DatatypeProperty
comment: An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition.
domain: RequirementDefinition
range: string

RequirementUsage
type: Class
comment: A RequirementUsage is a Usage of a RequirementDefinition. actorParameter = featureMembership-> selectByKind(ActorMembership). ownedActorParameter assumedConstraint = ownedFeatureMembership-> selectByKind(RequirementConstraintMembership)-> select(kind = RequirementConstraintKind::assumption). ownedConstraint framedConcern = featureMembership-> selectByKind(FramedConcernMembership). ownedConcern requiredConstraint = ownedFeatureMembership-> selectByKind(RequirementConstraintMembership)-> select(kind = RequirementConstraintKind::requirement). ownedConstraint stakeholderParameter = featureMembership-> selectByKind(AStakholderMembership). ownedStakeholderParameter subjectParameter = let subjects : OrderedSet(SubjectMembership) = featureMembership->selectByKind(SubjectMembership) in if subjects->isEmpty() then null else subjects->first().ownedSubjectParameter endif text = documentation.body featureMembership-> selectByKind(SubjectMembership)-> size() <= 1 input->notEmpty() and input->first() = subjectParameter specializesFromLibrary('Requirements::requirementChecks') isComposite and owningType <> null and (owningType.oclIsKindOf(RequirementDefinition) or owningType.oclIsKindOf(RequirementUsage)) implies specializesFromLibrary('Requirements::RequirementCheck::subrequirements') owningfeatureMembership <> null and owningfeatureMembership.oclIsKindOf(ObjectiveMembership) implies owningType.ownedSpecialization.general->forAll(gen | (gen.oclIsKindOf(CaseDefinition) implies redefines(gen.oclAsType(CaseDefinition).objectiveRequirement)) and (gen.oclIsKindOf(CaseUsage) implies redefines(gen.oclAsType(CaseUsage).objectiveRequirement)) owningFeatureMembership <> null and owningFeatureMembership.oclIsKindOf(RequirementVerificationMembership) implies specializesFromLibrary('VerificationCases::VerificationCase::obj::requirementVerifications')
subclass of: Restriction
  cardinality: 1
  on property: subjectParameter
subclass of: ConstraintUsage

actorParameter
is ordered: true
type: ObjectProperty
comment: The parameters of this RequirementUsage that represent actors involved in the requirement.
domain: RequirementUsage
range: PartUsage
sub property of: parameter
sub property of: usage

assumedConstraint
is ordered: true
type: ObjectProperty
comment: The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption.
domain: RequirementUsage
range: ConstraintUsage
sub property of: ownedFeature

framedConcern
is ordered: true
type: ObjectProperty
comment: The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage.
domain: RequirementUsage
range: ConcernUsage
sub property of: requiredConstraint

reqId
type: DatatypeProperty
type: FunctionalProperty
comment: An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage.
domain: RequirementUsage
range: string
sub property of: declaredShortName

requiredConstraint
is ordered: true
type: ObjectProperty
comment: The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement.
domain: RequirementUsage
range: ConstraintUsage
sub property of: ownedFeature

requirementDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The RequirementDefinition that is the single definition of this RequirementUsage.
domain: RequirementUsage
range: RequirementDefinition
sub property of: constraintDefinition

stakeholderParameter
is ordered: true
type: ObjectProperty
comment: The parameters of this RequirementUsage that represent stakeholders for the requirement.
domain: RequirementUsage
range: PartUsage
sub property of: parameter
sub property of: usage

subjectParameter
type: FunctionalProperty
type: ObjectProperty
comment: The parameter of this RequirementUsage that represents its subject.
domain: RequirementUsage
range: Usage
sub property of: parameter
sub property of: usage

text
type: DatatypeProperty
comment: An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.
domain: RequirementUsage
range: string

RequirementVerificationMembership
type: Class
comment: A RequirementVerificationMembership is a RequirementConstraintMembership used in the objective of a VerificationCase to identify a RequirementUsage that is verified by the VerificationCase. kind = RequirementConstraintKind::requirement owningType.oclIsKindOf(RequirementUsage) and owningType.owningFeatureMembership <> null and owningType.owningFeatureMembership.oclIsKindOf(ObjectiveMembership)
subclass of: Restriction
  cardinality: 1
  on property: ownedRequirement
subclass of: Restriction
  cardinality: 1
  on property: verifiedRequirement
subclass of: RequirementConstraintMembership

ownedRequirement
type: FunctionalProperty
type: ObjectProperty
comment: The owned RequirementUsage that acts as the ownedConstraint for this RequirementVerificationMembership. This will either be the verifiedRequirement, or it will subset the verifiedRequirement.
domain: RequirementVerificationMembership
range: RequirementUsage
sub property of: ownedConstraint

verifiedRequirement
type: FunctionalProperty
type: ObjectProperty
comment: The RequirementUsage that is identified as being verified. It is the referencedConstraint of the RequirementVerificationMembership considered as a RequirementConstraintMembership, which must be a RequirementUsage.
domain: RequirementVerificationMembership
range: RequirementUsage
sub property of: referencedConstraint

ResultExpressionMembership
type: Class
comment: A ResultExpressionMembership is a FeatureMembership that indicates that the ownedResultExpression provides the result values for the Function or Expression that owns it. The owning Function or Expression must contain a BindingConnector between the result parameter of the ownedResultExpression and the result parameter of the owning Function or Expression. owningType.oclIsKindOf(Function) or owningType.oclIsKindOf(Expression)
subclass of: Restriction
  cardinality: 1
  on property: ownedResultExpression
subclass of: FeatureMembership

ownedResultExpression
type: FunctionalProperty
type: ObjectProperty
comment: The Expression that provides the result for the owner of the ResultExpressionMembership.
domain: ResultExpressionMembership
range: Expression
sub property of: ownedMemberFeature

ReturnParameterMembership
type: Class
comment: A ReturnParameterMembership is a ParameterMembership that indicates that the ownedMemberParameter is the result parameter of a Function or Expression. The direction of the ownedMemberParameter must be out. owningType.oclIsKindOf(Function) or owningType.oclIsKindOf(Expression)
subclass of: ParameterMembership

SatisfyRequirementUsage
type: Class
comment: A SatisfyRequirementUsage is an AssertConstraintUsage that asserts, by default, that a satisfied RequirementUsage is true for a specific satisfyingFeature, or, if isNegated = true, that the RequirementUsage is false. The satisfied RequirementUsage is related to the SatisfyRequirementUsage by a ReferenceSubsetting Relationship. satisfyingFeature = let bindings: BindingConnector = ownedMember-> selectByKind(BindingConnector)-> select(b | b.relatedElement->includes(subjectParameter)) in if bindings->isEmpty() or bindings->first().relatedElement->exits(r | r <> subjectParameter) then null else bindings->first().relatedElement->any(r | r <> subjectParameter) endif ownedMember->selectByKind(BindingConnector)-> select(b | b.relatedElement->includes(subjectParameter) and b.relatedElement->exists(r | r <> subjectParameter))-> size() = 1 ownedReferenceSubsetting <> null implies ownedReferenceSubsetting.referencedFeature.oclIsKindOf(RequirementUsage)
subclass of: Restriction
  cardinality: 1
  on property: satisfiedRequirement
subclass of: Restriction
  cardinality: 1
  on property: satisfyingFeature
subclass of: AssertConstraintUsage
subclass of: RequirementUsage

satisfiedRequirement
type: FunctionalProperty
type: ObjectProperty
comment: The RequirementUsage that is satisfied by the satisfyingSubject of this SatisfyRequirementUsage. It is the assertedConstraint of the SatisfyRequirementUsage considered as an AssertConstraintUsage, which must be a RequirementUsage.
domain: SatisfyRequirementUsage
range: RequirementUsage
sub property of: assertedConstraint

satisfyingFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that represents the actual subject that is asserted to satisfy the satisfiedRequirement. The satisfyingFeature is bound to the subjectParameter of the SatisfyRequirementUsage.
domain: SatisfyRequirementUsage
range: Feature

SelectExpression
type: Class
comment: A SelectExpression is an OperatorExpression whose operator is "select", which resolves to the Function ControlFunctions::select from the Kernel Functions Library. operator = 'select'
subclass of: OperatorExpression

SendActionUsage
type: Class
comment: A SendActionUsage is an ActionUsage that specifies the sending of a payload given by the result of its payloadArgument Expression via a MessageTransfer whose source is given by the result of the senderArgument Expression and whose target is given by the result of the receiverArgument Expression. If no senderArgument is provided, the default is the this context for the action. If no receiverArgument is given, then the receiver is to be determined by, e.g., outgoing Connections from the sender. senderArgument = argument(2) payloadArgument = argument(1) inputParameters()->size() >= 3 receiverArgument = argument(3) isSubactionUsage() implies specializesFromLibrary('Actions::Action::acceptSubactions') specializesFromLibrary('Actions::sendActions')
subclass of: Restriction
  cardinality: 1
  on property: payloadArgument
subclass of: ActionUsage

payloadArgument
type: FunctionalProperty
type: ObjectProperty
comment: An Expression whose result is bound to the payload input parameter of this SendActionUsage.
domain: SendActionUsage
range: Expression

receiverArgument
type: FunctionalProperty
type: ObjectProperty
comment: An Expression whose result is bound to the receiver input parameter of this SendActionUsage.
domain: SendActionUsage
range: Expression

senderArgument
type: FunctionalProperty
type: ObjectProperty
comment: An Expression whose result is bound to the sender input parameter of this SendActionUsage.
domain: SendActionUsage
range: Expression

Specialization
type: Class
comment: Specialization is a Relationship between two Types that requires all instances of the specific type to also be instances of the general Type (i.e., the set of instances of the specific Type is a subset of those of the general Type, which might be the same set). not specific.isConjugated
subclass of: Restriction
  cardinality: 1
  on property: general
subclass of: Restriction
  cardinality: 1
  on property: specific
subclass of: Relationship

general
type: FunctionalProperty
type: ObjectProperty
comment: A Type with a superset of all instances of the specific Type, which might be the same set.
domain: Specialization
range: Type
sub property of: target

owningType
type: FunctionalProperty
type: ObjectProperty
comment: The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement.
domain: Specialization
range: Type
sub property of: owningRelatedElement
sub property of: specific

specific
type: FunctionalProperty
type: ObjectProperty
comment: A Type with a subset of all instances of the general Type, which might be the same set.
domain: Specialization
range: Type
sub property of: source

StakeholderMembership
type: Class
comment: A StakeholderMembership is a ParameterMembership that identifies a PartUsage as a stakeholderParameter of a RequirementDefinition or RequirementUsage, which specifies a role played by an entity with concerns framed by the owningType. owningType.oclIsKindOf(RequirementUsage) or owningType.oclIsKindOf(RequirementDefinition)
subclass of: Restriction
  cardinality: 1
  on property: ownedStakeholderParameter
subclass of: ParameterMembership

ownedStakeholderParameter
type: FunctionalProperty
type: ObjectProperty
comment: The PartUsage specifying the stakeholder.
domain: StakeholderMembership
range: PartUsage
sub property of: ownedMemberParameter

StateDefinition
type: Class
comment: A StateDefinition is the Definition of the Behavior of a system or part of a system in a certain state condition. A StateDefinition may be related to up to three of its ownedFeatures by StateBehaviorMembership Relationships, all of different kinds, corresponding to the entry, do and exit actions of the StateDefinition. specializesFromLibrary('States::StateAction') ownedMembership-> selectByKind(StateSubactionMembership)-> isUnique(kind) state = action->selectByKind(StateUsage) doAction = let doMemberships : Sequence(StateSubactionMembership) = ownedMembership-> selectByKind(StateSubactionMembership)-> select(kind = StateSubactionKind::do) in if doMemberships->isEmpty() then null else doMemberships->at(1) endif entryAction = let entryMemberships : Sequence(StateSubactionMembership) = ownedMembership-> selectByKind(StateSubactionMembership)-> select(kind = StateSubactionKind::entry) in if entryMemberships->isEmpty() then null else entryMemberships->at(1) endif isParallel implies ownedAction.incomingTransition->isEmpty() and ownedAction.outgoingTransition->isEmpty() exitAction = let exitMemberships : Sequence(StateSubactionMembership) = ownedMembership-> selectByKind(StateSubactionMembership)-> select(kind = StateSubactionKind::exit) in if exitMemberships->isEmpty() then null else exitMemberships->at(1) endif
subclass of: Restriction
  cardinality: 1
  on property: isParallel
subclass of: ActionDefinition

doAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage of this StateDefinition to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = do.
domain: StateDefinition
range: ActionUsage

entryAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage of this StateDefinition to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = entry.
domain: StateDefinition
range: ActionUsage

exitAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage of this StateDefinition to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = exit.
domain: StateDefinition
range: ActionUsage

isParallel
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the ownedStates of this StateDefinition are to all be performed in parallel. If true, none of the ownedActions (which includes ownedStates) may have any incoming or outgoing Transitions. If false, only one ownedState may be performed at a time.
domain: StateDefinition
range: boolean

state
is ordered: true
type: ObjectProperty
comment: The StateUsages, which are actions in the StateDefinition, that specify the discrete states in the behavior defined by the StateDefinition.
domain: StateDefinition
range: StateUsage
sub property of: action

StateSubactionKind
type: Datatype
comment: A StateSubactionKind indicates whether the action of a StateSubactionMembership is an entry, do or exit action.
equivalent class: Datatype
  one of: do
  one of: entry
  one of: exit

StateSubactionMembership
type: Class
comment: A StateSubactionMembership is a FeatureMembership for an entry, do or exit ActionUsage of a StateDefinition or StateUsage. owningType.oclIsKindOf(StateDefinition) or owningType.oclIsKindOf(StateUsage)
subclass of: Restriction
  cardinality: 1
  on property: action
subclass of: Restriction
  cardinality: 1
  on property: kind
subclass of: FeatureMembership

action
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage that is the ownedMemberFeature of this StateSubactionMembership.
domain: StateSubactionMembership
range: ActionUsage
sub property of: ownedMemberFeature

kind
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this StateSubactionMembership is for an entry, do or exit ActionUsage.
domain: StateSubactionMembership
range: StateSubactionKind

StateUsage
type: Class
comment: A StateUsage is an ActionUsage that is nominally the Usage of a StateDefinition. However, other kinds of kernel Behaviors are also allowed as types, to permit use of Behaviors</code from the Kernel Model Libraries. A StateUsage may be related to up to three of its ownedFeatures by StateSubactionMembership Relationships, all of different kinds, corresponding to the entry, do and exit actions of the StateUsage. doAction = let doMemberships : Sequence(StateSubactionMembership) = ownedMembership-> selectByKind(StateSubactionMembership)-> select(kind = StateSubactionKind::do) in if doMemberships->isEmpty() then null else doMemberships->at(1) endif entryAction = let entryMemberships : Sequence(StateSubactionMembership) = ownedMembership-> selectByKind(StateSubactionMembership)-> select(kind = StateSubactionKind::entry) in if entryMemberships->isEmpty() then null else entryMemberships->at(1) endif isParallel implies nestedAction.incomingTransition->isEmpty() and nestedAction.outgoingTransition->isEmpty() isSubstateUsage(false) implies specializesFromLibrary('States::StateAction::exclusiveStates') exitAction = let exitMemberships : Sequence(StateSubactionMembership) = ownedMembership-> selectByKind(StateSubactionMembership)-> select(kind = StateSubactionKind::exit) in if exitMemberships->isEmpty() then null else exitMemberships->at(1) endif specializesFromLibrary('States::stateActions') ownedMembership-> selectByKind(StateSubactionMembership)-> isUnique(kind) isSubstateUsage(true) implies specializesFromLibrary('States::StateAction::substates')
subclass of: Restriction
  cardinality: 1
  on property: isParallel
subclass of: ActionUsage

doAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do.
domain: StateUsage
range: ActionUsage

entryAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry.
domain: StateUsage
range: ActionUsage

exitAction
type: FunctionalProperty
type: ObjectProperty
comment: The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit.
domain: StateUsage
range: ActionUsage

isParallel
type: DatatypeProperty
type: FunctionalProperty
comment: Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time.
domain: StateUsage
range: boolean

stateDefinition
is ordered: true
type: ObjectProperty
comment: The Behaviors that are the types of this StateUsage. Nominally, these would be StateDefinitions, but kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries.
domain: StateUsage
range: Behavior
sub property of: actionDefinition

Step
type: Class
comment: A Step is a Feature that is typed by one or more Behaviors. Steps may be used by one Behavior to coordinate the performance of other Behaviors, supporting a steady refinement of behavioral descriptions. Steps can be ordered in time and can be connected using ItemFlows to specify things flowing between their parameters. specializesFromLibrary('Performances::performances') owningType <> null and (owningType.oclIsKindOf(Behavior) or owningType.oclIsKindOf(Step)) implies specializesFromLibrary('Performances::Performance::enclosedPerformance') isComposite and owningType <> null and (owningType.oclIsKindOf(Structure) or owningType.oclIsKindOf(Feature) and owningType.oclAsType(Feature).type-> exists(oclIsKindOf(Structure)) implies specializesFromLibrary('Objects::Object::ownedPerformance') owningType <> null and (owningType.oclIsKindOf(Behavior) or owningType.oclIsKindOf(Step)) and self.isComposite implies specializesFromLibrary('Performances::Performance::subperformance') behavior = type->selectByKind(Behavior)
subclass of: Feature

behavior
is ordered: true
type: ObjectProperty
comment: The Behaviors that type this Step.
domain: Step
range: Behavior
sub property of: type

parameter
is ordered: true
type: ObjectProperty
comment: The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step.
domain: Step
range: Feature
sub property of: directedFeature

Structure
type: Class
comment: A Structure is a Class of objects in the modeled universe that are primarily structural in nature. While such an object is not itself behavioral, it may be involved in and acted on by Behaviors, and it may be the performer of some of them. specializesFromLibrary('Objects::Object') ownedSpecialization.general->forAll(not oclIsKindOf(Behavior))
subclass of: Class

Subclassification
type: Class
comment: Subclassification is Specialization in which both the specific and general Types are Classifier. This means all instances of the specific Classifier are also instances of the general Classifier.
subclass of: Restriction
  cardinality: 1
  on property: subclassifier
subclass of: Restriction
  cardinality: 1
  on property: superclassifier
subclass of: Specialization

owningClassifier
type: FunctionalProperty
type: ObjectProperty
comment: The Classifier that owns this Subclassification relationship, which must also be its subclassifier.
domain: Subclassification
range: Classifier
sub property of: owningType

subclassifier
type: FunctionalProperty
type: ObjectProperty
comment: The more specific Classifier in this Subclassification.
domain: Subclassification
range: Classifier
sub property of: specific

superclassifier
type: FunctionalProperty
type: ObjectProperty
comment: The more general Classifier in this Subclassification.
domain: Subclassification
range: Classifier
sub property of: general

SubjectMembership
type: Class
comment: A SubjectMembership is a ParameterMembership that indicates that its ownedSubjectParameter is the subject of its owningType. The owningType of a SubjectMembership must be a RequirementDefinition, RequirementUsage, CaseDefinition, or CaseUsage. owningType.oclIsType(RequirementDefinition) or owningType.oclIsType(RequiremenCaseRequirementDefinition) or owningType.oclIsType(CaseDefinition) or owningType.oclIsType(CaseUsage)
subclass of: Restriction
  cardinality: 1
  on property: ownedSubjectParameter
subclass of: ParameterMembership

ownedSubjectParameter
type: FunctionalProperty
type: ObjectProperty
comment: The Usage</code< that is the ownedMemberParameter of this SubjectMembership.
domain: SubjectMembership
range: Usage
sub property of: ownedMemberParameter

Subsetting
type: Class
comment: Subsetting is Specialization in which the specific and general Types are Features. This means all values of the subsettingFeature (on instances of its domain, i.e., the intersection of its featuringTypes) are values of the subsettedFeature on instances of its domain. To support this the domain of the subsettingFeature must be the same or specialize (at least indirectly) the domain of the subsettedFeature (via Specialization), and the co-domain (intersection of the types) of the subsettingFeature must specialize the co-domain of the subsettedFeature. let subsettingFeaturingTypes: OrderedSet(Type) = subsettingFeature.featuringTypes in let subsettedFeaturingTypes: OrderedSet(Type) = subsettedFeature.featuringTypes in let anythingType: Element = subsettingFeature.resolveGlobal('Base::Anything').memberElement in subsettedFeaturingTypes->forAll(t | subsettingFeaturingTypes->isEmpty() and t = anythingType or subsettingFeaturingTypes->exists(specializes(t)) subsettedFeature.isUnique implies subsettingFeature.isUnique
subclass of: Restriction
  cardinality: 1
  on property: subsettedFeature
subclass of: Restriction
  cardinality: 1
  on property: subsettingFeature
subclass of: Specialization

owningFeature
type: FunctionalProperty
type: ObjectProperty
comment: A subsettingFeature that is also the owningRelatedElement of this Subsetting.
domain: Subsetting
range: Feature
sub property of: owningType
sub property of: subsettingFeature

subsettedFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is subsetted by the subsettingFeature of this Subsetting.
domain: Subsetting
range: Feature
sub property of: general

subsettingFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is a subset of the subsettedFeature of this Subsetting.
domain: Subsetting
range: Feature
sub property of: specific

Succession
type: Class
comment: A Succession is a binary Connector that requires its relatedFeatures to happen separately in time. specializesFromLibrary('Occurences::happensBeforeLinks') transitionStep = if owningNamespace.oclIsKindOf(Step) and owningNamespace.oclAsType(Step). specializesFromLibrary('TransitionPerformances::TransitionPerformance') then owningNamespace.oclAsType(Step) else null endif triggerStep = if transitionStep = null or transitionStep.ownedFeature.size() < 2 or not transitionStep.ownedFeature->at(2).oclIsKindOf(Step) then Set{} else Set{transitionStep.ownedFeature->at(2).oclAsType(Step)} endif effectStep = if transitionStep = null or transitionStep.ownedFeature.size() < 4 or not transitionStep.ownedFeature->at(4).oclIsKindOf(Step) then Set{} else Set{transitionStep.ownedFeature->at(4).oclAsType(Step)} endif guardExpression = if transitionStep = null or transitionStep.ownedFeature.size() < 3 or not transitionStep.ownedFeature->at(3).oclIsKindOf(Expression) then Set{} else Set{transitionStep.ownedFeature->at(3).oclAsType(Expression)} endif
subclass of: Connector

SuccessionAsUsage
type: Class
comment: A SuccessionAsUsage is both a ConnectorAsUsage and a Succession.
subclass of: ConnectorAsUsage
subclass of: Succession

SuccessionFlowConnectionUsage
type: Class
comment: A SuccessionFlowConnectionUsage is a FlowConnectionUsage that is also a SuccessionItemFlow. specializesFromLibrary('Connections::successionFlowConnections')
subclass of: FlowConnectionUsage
subclass of: SuccessionItemFlow

SuccessionItemFlow
type: Class
comment: A SuccessionItemFlow is an ItemFlow that also provides temporal ordering. It classifies Transfers that cannot start until the source Occurrence has completed and that must complete before the target Occurrence can start. specializesFromLibrary('Transfers::flowTransfersBefore')
subclass of: ItemFlow
subclass of: Succession

effectStep
type: ObjectProperty
comment: Steps that represent occurrences that are side effects of the transitionStep occurring.
domain: Succession
range: Step

guardExpression
type: ObjectProperty
comment: Expressions that must evaluate to true before the transitionStep can occur.
domain: Succession
range: Expression

transitionStep
type: FunctionalProperty
type: ObjectProperty
comment: A Step that is typed by the Behavior TransitionPerformances::TransitionPerformance (from the Kernel Semantic Library) that has this Succession as its transitionLink.
domain: Succession
range: Step

triggerStep
type: ObjectProperty
comment: Steps that map incoming events to the timing of occurrences of the transitionStep. The values of triggerStep subset the list of acceptable events to be received by a Behavior or the object that performs it.
domain: Succession
range: Step

TextualRepresentation
type: Class
comment: A TextualRepresentation is an AnnotatingElement whose body represents the representedElement in a given language. The representedElement must be the owner of the TextualRepresentation. The named language can be a natural language, in which case the body is an informal representation, or an artificial language, in which case the body is expected to be a formal, machine-parsable representation. If the named language of a TextualRepresentation is machine-parsable, then the body text should be legal input text as defined for that language. The interpretation of the named language string shall be case insensitive. The following language names are defined to correspond to the given standard languages: kerml Kernel Modeling Language ocl Object Constraint Language alf Action Language for fUML Other specifications may define specific language strings, other than those shown above, to be used to indicate the use of languages from those specifications in KerML TextualRepresentation. If the language of a TextualRepresentation is "kerml", then the body text shall be a legal representation of the representedElement in the KerML textual concrete syntax. A conforming tool can use such a TextualRepresentation Annotation to record the original KerML concrete syntax text from which an Element was parsed. In this case, it is a tool responsibility to ensure that the body of the TextualRepresentation remains correct (or the Annotation is removed) if the annotated Element changes other than by re-parsing the body text. An Element with a TextualRepresentation in a language other than KerML is essentially a semantically "opaque" Element specified in the other language. However, a conforming KerML tool may interpret such an element consistently with the specification of the named language.
subclass of: Restriction
  cardinality: 1
  on property: representedElement
subclass of: Restriction
  cardinality: 1
  on property: body
subclass of: Restriction
  cardinality: 1
  on property: language
subclass of: AnnotatingElement

body
type: DatatypeProperty
type: FunctionalProperty
comment: The textual representation of the representedElement in the given language.
domain: TextualRepresentation
range: string

language
type: DatatypeProperty
type: FunctionalProperty
comment: The natural or artifical language in which the body text is written.
domain: TextualRepresentation
range: string

representedElement
type: FunctionalProperty
type: ObjectProperty
comment: The Element that is represented by this TextualRepresentation.
domain: TextualRepresentation
range: Element
sub property of: annotatedElement
inverse of: textualRepresentation

TransitionFeatureKind
type: Datatype
comment: A TransitionActionKind indicates whether the transitionFeature of a TransitionFeatureMembership is a trigger, guard or effect.
equivalent class: Datatype
  one of: effect
  one of: guard
  one of: trigger

TransitionFeatureMembership
type: Class
comment: A TransitionFeatureMembership is a FeatureMembership for a trigger, guard or effect of a TransitionUsage, whose transitionFeature is a AcceptActionUsage, Boolean-valued Expression or ActionUsage, depending on its kind. kind = TransitionFeatureKind::trigger implies transitionFeature.oclIsKindOf(AcceptActionUsage) owningType.oclIsKindOf(TransitionUsage) kind = TransitionFeatureKind::guard implies transitionFeature.oclIsKindOf(Expression) and let guard : Expression = transitionFeature.oclIsKindOf(Expression) in guard.result.specializesFromLibrary('ScalarValues::Boolean') and guard.result.multiplicity <> null and guard.result.multiplicity.hasBounds(1,1) kind = TransitionFeatureKind::effect implies transitionFeature.oclIsKindOf(ActionUsage)
subclass of: Restriction
  cardinality: 1
  on property: transitionFeature
subclass of: Restriction
  cardinality: 1
  on property: kind
subclass of: FeatureMembership

kind
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this TransitionFeatureMembership is for a trigger, guard or effect.
domain: TransitionFeatureMembership
range: TransitionFeatureKind

transitionFeature
type: FunctionalProperty
type: ObjectProperty
comment: The Step that is the ownedMemberFeature of this TransitionFeatureMembership.
domain: TransitionFeatureMembership
range: Step
sub property of: ownedMemberFeature

TransitionUsage
type: Class
comment: A TransitionUsage is an ActionUsage representing a triggered transition between ActionUsages or StateUsages. When triggered by a triggerAction, when its guardExpression is true, the TransitionUsage asserts that its source is exited, then its effectAction (if any) is performed, and then its target is entered. A TransitionUsage can be related to some of its ownedFeatures using TransitionFeatureMembership Relationships, corresponding to the triggerAction, guardExpression and effectAction of the TransitionUsage. isComposite and owningType <> null and (owningType.oclIsKindOf(ActionDefinition) or owningType.oclIsKindOf(ActionUsage)) and not (owningType.oclIsKindOf(StateDefinition) or owningType.oclIsKindOf(StateUsage)) implies specializesFromLibrary('Actions::Action::decisionTransitions') isComposite and owningType <> null and (owningType.oclIsKindOf(StateDefinition) or owningType.oclIsKindOf(StateUsage)) implies specializesFromLibrary('States::State::stateTransitions') specializesFromLibrary('Actions::transitionActions') source = if ownedMembership->isEmpty() then null else let member : Element = ownedMembership->at(1).memberElement in if not member.oclIsKindOf(ActionUsage) then null else member.oclAsKindOf(ActionUsage) endif endif target = if succession.targetFeature->isEmpty() then null else let targetFeature : Feature = succession.targetFeature->at(1) in if not targetFeature.oclIsKindOf(ActionUsage) then null else targetFeature.oclAsType(ActionUsage) endif endif triggerAction = ownedFeatureMembership-> selectByKind(TransitionFeatureMembership)-> select(kind = TransitionFeatureKind::trigger).transitionFeature-> selectByKind(AcceptActionUsage) let successions : Sequence(Successions) = ownedMember->selectByKind(Succession) in successions->notEmpty() and successions->at(1).targetFeature-> forAll(oclIsKindOf(ActionUsage)) guardExpression = ownedFeatureMembership-> selectByKind(TransitionFeatureMembership)-> select(kind = TransitionFeatureKind::trigger).transitionFeature-> …
subclass of: Restriction
  cardinality: 1
  on property: source
subclass of: Restriction
  cardinality: 1
  on property: succession
subclass of: Restriction
  cardinality: 1
  on property: target
subclass of: ActionUsage

effectAction
type: ObjectProperty
comment: The ActionUsages that define the effects of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = effect, which must all be ActionUsages.
domain: TransitionUsage
range: ActionUsage
sub property of: feature

guardExpression
type: ObjectProperty
comment: The Expressions that define the guards of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = guard, which must all be Expressions.
domain: TransitionUsage
range: Expression
sub property of: ownedFeature

source
type: FunctionalProperty
type: ObjectProperty
comment: The source ActionUsage of this TransitionUsage, which becomes the source of the succession for the TransitionUsage.
domain: TransitionUsage
range: ActionUsage

succession
type: FunctionalProperty
type: ObjectProperty
comment: The Succession that is the ownedFeature of this TransitionUsage, which, if the TransitionUsage is triggered, asserts the temporal ordering of the source and target.
domain: TransitionUsage
range: Succession
sub property of: ownedMember

target
type: FunctionalProperty
type: ObjectProperty
comment: The target ActionUsage of this TransitionUsage, which is the targetFeature of the succession for the TransitionUsage.
domain: TransitionUsage
range: ActionUsage

triggerAction
type: ObjectProperty
comment: The AcceptActionUsages that define the triggers of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = trigger, which must all be AcceptActionUsages.
domain: TransitionUsage
range: AcceptActionUsage
sub property of: ownedFeature

TriggerInvocationExpression
type: Class
comment: A TriggerInvocationExpression is an InvocationExpression that invokes one of the trigger Functions from the Kernel Semantic Library Triggers package, as indicated by its kind. specializesFromLibrary( if kind = TriggerKind::when then 'Triggers::TriggerWhen' else if kind = TriggerKind::at then 'Triggers::TriggerAt' else 'Triggers::TriggerAfter' endif endif ) kind = TriggerKind::after implies argument->notEmpty() and argument->at(1).result.specializesFromLibrary('Quantities::ScalarQuantityValue') and let mRef : Element = resolveGlobal('Quantities::TensorQuantityValue::mRef').ownedMemberElement in argument->at(1).result.feature-> select(ownedRedefinition.redefinedFeature-> closure(ownedRedefinition.redefinedFeature)-> includes(mRef))-> exists(specializesFromLibrary('ISQBase::DurationUnit')) kind = TriggerKind::at implies argument->notEmpty() and argument->at(1).result.specializesFromLibrary('Time::TimeInstantValue') kind = TriggerKind::when implies argument->notEmpty() and argument->at(1).oclIsKindOf(FeatureReferenceExpression) and let referent : Feature = argument->at(1).oclAsType(FeatureReferenceExpression).referent in referent.oclIsKindOf(Expression) and referent.oclAsType(Expression).result.specializesFromLibrary('ScalarValues::Boolean')
subclass of: Restriction
  cardinality: 1
  on property: kind
subclass of: InvocationExpression

kind
type: DatatypeProperty
type: FunctionalProperty
comment: Indicates which of the Functions from the Triggers model in the Kernel Semantic Library is to be invoked by this TriggerInvocationExpression.
domain: TriggerInvocationExpression
range: TriggerKind

TriggerKind
type: Datatype
comment: TriggerKind enumerates the kinds of triggers that can be represented by a TriggerInvocationExpression.
equivalent class: Datatype
  one of: after
  one of: at
  one of: when

Type
type: Class
comment: A Type is a Namespace that is the most general kind of Element supporting the semantics of classification. A Type may be a Classifier or a Feature, defining conditions on what is classified by the Type (see also the description of isSufficient). ownedSpecialization = ownedRelationship->selectByKind(Specialization)-> select(s | s.special = self) multiplicity = let ownedMultiplicities: Sequence(Multiplicity) = ownedMember->selectByKind(Multiplicity) in if ownedMultiplicities->isEmpty() then null else ownedMultiplicities->first() endif ownedFeatureMembership = ownedRelationship->selectByKind(FeatureMembership) ownedConjugator = let ownedConjugators: Sequence(Conjugator) = ownedRelationship->selectByKind(Conjugation) in if ownedConjugators->isEmpty() then null else ownedConjugators->at(1) endif output = feature->select(f | let direction: FeatureDirectionKind = directionOf(f) in direction = FeatureDirectionKind::out or direction = FeatureDirectionKind::inout) input = feature->select(f | let direction: FeatureDirectionKind = directionOf(f) in direction = FeatureDirectionKind::_'in' or direction = FeatureDirectionKind::inout) inheritedMembership = inheritedMemberships(Set{}, false) specializesFromLibrary('Base::Anything') directedFeature = feature->select(f | directionOf(f) <> null) feature = featureMembership.ownedMemberFeature featureMembership = ownedFeatureMembership->union( inheritedMembership->selectByKind(FeatureMembership)) ownedFeature = ownedFeatureMembership.ownedMemberFeature differencingType = ownedDifferencing.differencingType intersectingType->excludes(self) differencingType->excludes(self) unioningType = ownedUnioning.unioningType unioningType->excludes(self) intersectingType = ownedIntersecting.intersectingType ownedRelationship->selectByKind(Conjugation)->size() <= 1 ownedMember->selectByKind(Multiplicity)->size() <= 1 endFeature = feature->select(isEnd) ownedDisjoining = ownedRelationship->selectByKind(Disjoining) ownedUnioning = ownedRelationship->selec…
subclass of: Restriction
  cardinality: 1
  on property: isAbstract
subclass of: Restriction
  cardinality: 1
  on property: isConjugated
subclass of: Restriction
  cardinality: 1
  on property: isSufficient
subclass of: Namespace

TypeFeaturing
type: Class
comment: A TypeFeaturing is a Featuring Relationship in which the featureOfType is the source and the featuringType is the target.
subclass of: Restriction
  cardinality: 1
  on property: featureOfType
subclass of: Restriction
  cardinality: 1
  on property: featuringType
subclass of: Featuring

featureOfType
type: FunctionalProperty
type: ObjectProperty
comment: The Feature that is featured by the featuringType. It is the source of the TypeFeaturing.
domain: TypeFeaturing
range: Feature
sub property of: feature
sub property of: source

featuringType
type: FunctionalProperty
type: ObjectProperty
comment: The Type that features the featureOfType. It is the target of the TypeFeaturing.
domain: TypeFeaturing
range: Type
sub property of: type
sub property of: target

owningFeatureOfType
type: FunctionalProperty
type: ObjectProperty
comment: A featureOfType that is also the owningRelatedElement of this TypeFeaturing.
domain: TypeFeaturing
range: Feature
sub property of: owningRelatedElement
sub property of: featureOfType

differencingType
is ordered: true
type: ObjectProperty
comment: The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex).
domain: Type
range: Type

directedFeature
is ordered: true
type: ObjectProperty
comment: The features of this Type that have a non-null direction.
domain: Type
range: Feature
sub property of: feature

endFeature
is ordered: true
type: ObjectProperty
comment: All features of this Type with isEnd = true.
domain: Type
range: Feature
sub property of: feature

feature
is ordered: true
type: ObjectProperty
comment: The ownedMemberFeatures of the featureMemberships of this Type.
domain: Type
range: Feature
sub property of: member

featureMembership
is ordered: true
type: ObjectProperty
comment: The FeatureMemberships for features of this Type, which include all ownedFeatureMemberships and those inheritedMemberships that are FeatureMemberships (but does not include any importedMemberships).
domain: Type
range: FeatureMembership

inheritedFeature
is ordered: true
type: ObjectProperty
comment: All the memberFeatures of the inheritedMemberships of this Type that are FeatureMemberships.
domain: Type
range: Feature
sub property of: feature

inheritedMembership
is ordered: true
type: ObjectProperty
comment: All Memberships inherited by this Type via Specialization or Conjugation. These are included in the derived union for the memberships of the Type.
domain: Type
range: Membership
sub property of: membership

input
is ordered: true
type: ObjectProperty
comment: All features related to this Type by FeatureMemberships that have direction in or inout.
domain: Type
range: Feature
sub property of: directedFeature

intersectingType
is ordered: true
type: ObjectProperty
comment: The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex).
domain: Type
range: Type

isAbstract
type: DatatypeProperty
type: FunctionalProperty
comment: Indicates whether instances of this Type must also be instances of at least one of its specialized Types.
domain: Type
range: boolean

isConjugated
type: DatatypeProperty
type: FunctionalProperty
comment: Indicates whether this Type has an ownedConjugator.
domain: Type
range: boolean

isSufficient
type: DatatypeProperty
type: FunctionalProperty
comment: Whether all things that meet the classification conditions of this Type must be classified by the Type. (A Type gives conditions that must be met by whatever it classifies, but when isSufficient is false, things may meet those conditions but still not be classified by the Type. For example, a Type Car that is not sufficient could require everything it classifies to have four wheels, but not all four wheeled things would classify as cars. However, if the Type Car were sufficient, it would classify all four-wheeled things.)
domain: Type
range: boolean

multiplicity
type: FunctionalProperty
type: ObjectProperty
comment: An ownedMember of this Type that is a Multiplicity, which constraints the cardinality of the Type. If there is no such ownedMember, then the cardinality of this Type is constrained by all the Multiplicity constraints applicable to any direct supertypes.
domain: Type
range: Multiplicity
sub property of: ownedMember

output
is ordered: true
type: ObjectProperty
comment: All features related to this Type by FeatureMemberships that have direction out or inout.
domain: Type
range: Feature
sub property of: directedFeature

ownedConjugator
type: InverseFunctionalProperty
type: ObjectProperty
comment: A Conjugation owned by this Type for which the Type is the originalType.
domain: Type
range: Conjugation
inverse of: owningType

ownedDifferencing
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Type that are Differencings, having this Type as their typeDifferenced.
domain: Type
range: Differencing
inverse of: typeDifferenced

ownedDisjoining
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Type that are Disjoinings, for which the Type is the typeDisjoined Type.
domain: Type
range: Disjoining
inverse of: owningType

ownedEndFeature
is ordered: true
type: ObjectProperty
comment: All endFeatures of this Type that are ownedFeatures.
domain: Type
range: Feature
sub property of: endFeature
sub property of: ownedFeature

ownedFeature
is ordered: true
type: ObjectProperty
comment: The ownedMemberFeatures of the ownedFeatureMemberships of this Type.
domain: Type
range: Feature
sub property of: ownedMember

ownedFeatureMembership
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedMemberships of this Type that are FeatureMemberships, for which the Type is the owningType. Each such FeatureMembership identifies an ownedFeature of the Type.
domain: Type
range: FeatureMembership
sub property of: featureMembership
inverse of: owningType

ownedIntersecting
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Type that are Intersectings, have the Type as their typeIntersected.
domain: Type
range: Intersecting
inverse of: typeIntersected

ownedSpecialization
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Type that are Specializations, for which the Type is the specific Type.
domain: Type
range: Specialization
inverse of: owningType

ownedUnioning
type: InverseFunctionalProperty
type: ObjectProperty
comment: The ownedRelationships of this Type that are Unionings, having the Type as their typeUnioned.
domain: Type
range: Unioning
inverse of: typeUnioned

unioningType
is ordered: true
type: ObjectProperty
comment: The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general.
domain: Type
range: Type

Unioning
type: Class
comment: Unioning is a Relationship that makes its unioningType one of the unioningTypes of its typeUnioned.
subclass of: Restriction
  cardinality: 1
  on property: typeUnioned
subclass of: Restriction
  cardinality: 1
  on property: unioningType
subclass of: Relationship

typeUnioned
type: FunctionalProperty
type: ObjectProperty
comment: Type with interpretations partly determined by unioningType, as described in Type::unioningType.
domain: Unioning
range: Type
sub property of: owningRelatedElement
sub property of: source

unioningType
type: FunctionalProperty
type: ObjectProperty
comment: Type that partly determines interpretations of typeUnioned, as described in Type::unioningType.
domain: Unioning
range: Type
sub property of: target

Usage
type: Class
comment: A Usage is a usage of a Definition. A Usage may only be an ownedFeature of a Definition or another Usage. A Usage may have nestedUsages that model features that apply in the context of the owningUsage. A Usage may also have Definitions nested in it, but this has no semantic significance, other than the nested scoping resulting from the Usage being considered as a Namespace for any nested Definitions. However, if a Usage has isVariation = true, then it represents a variation point Usage. In this case, all of its members must be variant Usages, related to the Usage by VariantMembership Relationships. Rather than being features of the Usage, variant Usages model different concrete alternatives that can be chosen to fill in for the variation point Usage. variant = variantMembership.ownedVariantUsage variantMembership = ownedMembership->selectByKind(VariantMembership) isVariation implies ownedFeatureMembership->isEmpty() isReference = not isComposite owningVariationUsage <> null implies specializes(owningVariationUsage) isVariation implies not ownedSpecialization.specific->exists( oclIsKindOf(Definition) and oclAsType(Definition).isVariation or oclIsKindOf(Usage) and oclAsType(Usage).isVariation) owningVariationDefinition <> null implies specializes(owningVariationDefinition) directedUsage = directedFeature->selectByKind(Usage) nestedAction = nestedUsage->selectByKind(ActionUsage) nestedAllocation = nestedUsage->selectByKind(AllocationUsage) nestedAnalysisCase = nestedUsage->selectByKind(AnalysisCaseUsage) nestedAttribute = nestedUsage->selectByKind(AttributeUsage) nestedCalculation = nestedUsage->selectByKind(CalculationUsage) nestedCase = nestedUsage->selectByKind(CaseUsage) nestedConcern = nestedUsage->selectByKind(ConcernUsage) nestedConnection = nestedUsage->selectByKind(ConnectorAsUsage) nestedConstraint = nestedUsage->selectByKind(ConstraintUsage) ownedNested = nestedUsage->selectByKind(EnumerationUsage) nestedFlow = nestedUsage->selectByKind(FlowConnectionUsage) …
subclass of: Restriction
  cardinality: 1
  on property: isReference
subclass of: Restriction
  cardinality: 1
  on property: isVariation
subclass of: Feature

definition
is ordered: true
type: ObjectProperty
comment: The Classifiers that are the types of this Usage. Nominally, these are Definitions, but other kinds of Kernel Classifiers are also allowed, to permit use of Classifiers from the Kernel Model Libraries.
domain: Usage
range: Classifier
sub property of: type

directedUsage
is ordered: true
type: ObjectProperty
comment: The usages of this Usage that are directedFeatures.
domain: Usage
range: Usage
sub property of: directedFeature
sub property of: usage

isReference
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Usage is a referential Usage, that is, it has isComposite = false.
domain: Usage
range: boolean

isVariation
type: DatatypeProperty
type: FunctionalProperty
comment: Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships.
domain: Usage
range: boolean

nestedAction
is ordered: true
type: ObjectProperty
comment: The ActionUsages that are nestedUsages of this Usage.
domain: Usage
range: ActionUsage
sub property of: nestedOccurrence

nestedAllocation
is ordered: true
type: ObjectProperty
comment: The AllocationUsages that are nestedUsages of this Usage.
domain: Usage
range: AllocationUsage
sub property of: nestedConnection

nestedAnalysisCase
is ordered: true
type: ObjectProperty
comment: The AnalysisCaseUsages that are nestedUsages of this Usage.
domain: Usage
range: AnalysisCaseUsage
sub property of: nestedCase

nestedAttribute
is ordered: true
type: ObjectProperty
comment: The code>AttributeUsages that are nestedUsages of this Usage.
domain: Usage
range: AttributeUsage
sub property of: nestedUsage

nestedCalculation
is ordered: true
type: ObjectProperty
comment: The CalculationUsage that are nestedUsages of this Usage.
domain: Usage
range: CalculationUsage
sub property of: nestedAction

nestedCase
is ordered: true
type: ObjectProperty
comment: The CaseUsages that are nestedUsages of this Usage.
domain: Usage
range: CaseUsage
sub property of: nestedCalculation

nestedConcern
type: ObjectProperty
comment: The ConcernUsages that are nestedUsages of this Usage.
domain: Usage
range: ConcernUsage
sub property of: nestedRequirement

nestedConnection
is ordered: true
type: ObjectProperty
comment: The ConnectorAsUsages that are nestedUsages of this Usage. Note that this list includes BindingConnectorAsUsages and SuccessionAsUsages, even though these are ConnectorAsUsages but not ConnectionUsages.
domain: Usage
range: ConnectorAsUsage
sub property of: nestedPart

nestedConstraint
is ordered: true
type: ObjectProperty
comment: The ConstraintUsages that are nestedUsages of this Usage.
domain: Usage
range: ConstraintUsage
sub property of: nestedOccurrence

nestedEnumeration
is ordered: true
type: ObjectProperty
comment: The code>EnumerationUsages that are nestedUsages of this Usage.
domain: Usage
range: EnumerationUsage
sub property of: nestedAttribute

nestedFlow
type: ObjectProperty
comment: The code>FlowConnectionUsages that are nestedUsages of this Usage.
domain: Usage
range: FlowConnectionUsage
sub property of: nestedConnection

nestedInterface
is ordered: true
type: ObjectProperty
comment: The InterfaceUsages that are nestedUsages of this Usage.
domain: Usage
range: InterfaceUsage
sub property of: nestedConnection

nestedItem
is ordered: true
type: ObjectProperty
comment: The ItemUsages that are nestedUsages of this Usage.
domain: Usage
range: ItemUsage
sub property of: nestedOccurrence

nestedMetadata
is ordered: true
type: ObjectProperty
comment: The MetadataUsages that are nestedUsages of this of this Usage.
domain: Usage
range: MetadataUsage
sub property of: nestedItem

nestedOccurrence
is ordered: true
type: ObjectProperty
comment: The OccurrenceUsages that are nestedUsages of this Usage.
domain: Usage
range: OccurrenceUsage
sub property of: nestedUsage

nestedPart
is ordered: true
type: ObjectProperty
comment: The PartUsages that are nestedUsages of this Usage.
domain: Usage
range: PartUsage
sub property of: nestedItem

nestedPort
is ordered: true
type: ObjectProperty
comment: The PortUsages that are nestedUsages of this Usage.
domain: Usage
range: PortUsage
sub property of: nestedUsage

nestedReference
is ordered: true
type: ObjectProperty
comment: The ReferenceUsages that are nestedUsages of this Usage.
domain: Usage
range: ReferenceUsage
sub property of: nestedUsage

nestedRendering
is ordered: true
type: ObjectProperty
comment: The RenderingUsages that are nestedUsages of this Usage.
domain: Usage
range: RenderingUsage
sub property of: nestedPart

nestedRequirement
is ordered: true
type: ObjectProperty
comment: The RequirementUsages that are nestedUsages of this Usage.
domain: Usage
range: RequirementUsage
sub property of: nestedConstraint

nestedState
is ordered: true
type: ObjectProperty
comment: The StateUsages that are nestedUsages of this Usage.
domain: Usage
range: StateUsage
sub property of: nestedAction

nestedTransition
type: ObjectProperty
comment: The TransitionUsages that are nestedUsages of this Usage.
domain: Usage
range: TransitionUsage
sub property of: nestedUsage

nestedUsage
is ordered: true
type: ObjectProperty
comment: The Usages that are ownedFeatures of this Usage.
domain: Usage
range: Usage
sub property of: ownedFeature
sub property of: usage

nestedUseCase
is ordered: true
type: ObjectProperty
comment: The UseCaseUsages that are nestedUsages of this Usage.
domain: Usage
range: UseCaseUsage
sub property of: nestedCase

nestedVerificationCase
is ordered: true
type: ObjectProperty
comment: The VerificationCaseUsages that are nestedUsages of this Usage.
domain: Usage
range: VerificationCaseUsage
sub property of: nestedCase

nestedView
is ordered: true
type: ObjectProperty
comment: The ViewUsages that are nestedUsages of this Usage.
domain: Usage
range: ViewUsage
sub property of: nestedPart

nestedViewpoint
is ordered: true
type: ObjectProperty
comment: The ViewpointUsages that are nestedUsages of this Usage.
domain: Usage
range: ViewpointUsage
sub property of: nestedRequirement

owningDefinition
type: ObjectProperty
comment: The Definition that owns this Usage (if any).
domain: Usage
range: Definition
inverse of: ownedUsage

owningUsage
type: ObjectProperty
comment: The Usage in which this Usage is nested (if any).
domain: Usage
range: Usage
inverse of: nestedUsage

usage
is ordered: true
type: ObjectProperty
comment: The Usages that are features of this Usage (not necessarily owned).
domain: Usage
range: Usage
sub property of: feature

variant
type: ObjectProperty
comment: The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants.
domain: Usage
range: Usage
sub property of: ownedMember

variantMembership
type: ObjectProperty
comment: The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty.
domain: Usage
range: VariantMembership
sub property of: ownedMembership

UseCaseDefinition
type: Class
comment: A UseCaseDefinition is a CaseDefinition that specifies a set of actions performed by its subject, in interaction with one or more actors external to the subject. The objective is to yield an observable result that is of value to one or more of the actors. includedUseCase = ownedUseCase-> selectByKind(IncludeUseCaseUsage). useCaseIncluded specializesFromLibrary('UseCases::UseCase')
subclass of: CaseDefinition

includedUseCase
is ordered: true
type: ObjectProperty
comment: The UseCaseUsages that are included by this UseCaseDefinition, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseDefinition.
domain: UseCaseDefinition
range: UseCaseUsage

UseCaseUsage
type: Class
comment: A UseCaseUsage is a Usage of a UseCaseDefinition. includedUseCase = ownedUseCase-> selectByKind(IncludeUseCaseUsage). useCaseIncluded specializesFromLibrary('UseCases::useCases') isComposite and owningType <> null and (owningType.oclIsKindOf(UseCaseDefinition) or owningType.oclIsKindOf(UseCaseUsage)) implies specializesFromLibrary('UseCases::UseCase::subUseCases')
subclass of: CaseUsage

includedUseCase
is ordered: true
type: ObjectProperty
comment: The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage.
domain: UseCaseUsage
range: UseCaseUsage

useCaseDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The UseCaseDefinition that is the definition of this UseCaseUsage.
domain: UseCaseUsage
range: UseCaseDefinition
sub property of: caseDefinition

VariantMembership
type: Class
comment: A VariantMembership is a Membership between a variation point Definition or Usage and a Usage that represents a variant in the context of that variation. The membershipOwningNamespace for the VariantMembership must be either a Definition or a Usage with isVariation = true. membershipOwningNamespace.oclIsKindOf(Definition) and membershipOwningNamespace.oclAsType(Definition).isVariation or membershipOwningNamespace.oclIsKindOf(Usage) and membershipOwningNamespace.oclAsType(Usage).isVariation
subclass of: Restriction
  cardinality: 1
  on property: ownedVariantUsage
subclass of: OwningMembership

ownedVariantUsage
type: FunctionalProperty
type: ObjectProperty
comment: The Usage that represents a variant in the context of the owningVariationDefinition or owningVariationUsage.
domain: VariantMembership
range: Usage
sub property of: ownedMemberElement

VerificationCaseDefinition
type: Class
comment: A VerificationCaseDefinition is a CaseDefinition for the purpose of verification of the subject of the case against its requirements. verifiedRequirement = if objectiveRequirement = null then OrderedSet{} else objectiveRequirement.featureMembership-> selectByKind(RequirementVerificationMembership). verifiedRequirement->asOrderedSet() endif specializesFromLibrary('VerificationCases::VerificationCase')
subclass of: CaseDefinition

verifiedRequirement
is ordered: true
type: ObjectProperty
comment: The RequirementUsages verified by this VerificationCaseDefinition, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement.
domain: VerificationCaseDefinition
range: RequirementUsage

VerificationCaseUsage
type: Class
comment: A VerificationCaseUsage is a Usage of a VerificationCaseDefinition. verifiedRequirement = if objectiveRequirement = null then OrderedSet{} else objectiveRequirement.featureMembership-> selectByKind(RequirementVerificationMembership). verifiedRequirement->asOrderedSet() endif specializesFromLibrary('VerificationCases::verificationCases') isComposite and owningType <> null and (owningType.oclIsKindOf(VerificationCaseDefinition) or owningType.oclIsKindOf(VerificationCaseUsage)) implies specializesFromLibrary('VerificationCases::VerificationCase::subVerificationCases')
subclass of: CaseUsage

verificationCaseDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The VerificationCase that is the definition of this VerificationCaseUsage.
domain: VerificationCaseUsage
range: VerificationCaseDefinition
sub property of: caseDefinition

verifiedRequirement
is ordered: true
type: ObjectProperty
comment: The RequirementUsages verified by this VerificationCaseUsage, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement.
domain: VerificationCaseUsage
range: RequirementUsage

ViewDefinition
type: Class
comment: A ViewDefinition is a PartDefinition that specifies how a view artifact is constructed to satisfy a viewpoint. It specifies a viewConditions to define the model content to be presented and a viewRendering to define how the model content is presented. view = usage->selectByKind(ViewUsage) satisfiedViewpoint = ownedRequirement-> selectByKind(ViewpointUsage)-> select(isComposite) viewRendering = let renderings: OrderedSet(ViewRenderingMembership) = featureMembership->selectByKind(ViewRenderingMembership) in if renderings->isEmpty() then null else renderings->first().referencedRendering endif viewCondition = ownedMembership-> selectByKind(ElementFilterMembership). condition featureMembership-> selectByKind(ViewRenderingMembership)-> size() <= 1 specializesFromLibrary('Views::View')
subclass of: PartDefinition

satisfiedViewpoint
is ordered: true
type: ObjectProperty
comment: The composite ownedRequirements of this ViewDefinition that are ViewpointUsages for viewpoints satisfied by the ViewDefinition.
domain: ViewDefinition
range: ViewpointUsage
sub property of: ownedRequirement

view
is ordered: true
type: ObjectProperty
comment: The usages of this ViewDefinition that are ViewUsages.
domain: ViewDefinition
range: ViewUsage
sub property of: usage

viewCondition
is ordered: true
type: ObjectProperty
comment: The Expressions related to this ViewDefinition by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view.
domain: ViewDefinition
range: Expression
sub property of: ownedMember

viewRendering
type: FunctionalProperty
type: ObjectProperty
comment: The RenderingUsage to be used to render views defined by this ViewDefinition, which is the referencedRendering of the ViewRenderingMembership of the ViewDefinition.
domain: ViewDefinition
range: RenderingUsage

ViewRenderingMembership
type: Class
comment: A ViewRenderingMembership is a <coed>FeatureMembership that identifies the viewRendering of a ViewDefinition or ViewUsage. referencedRendering = let reference: ReferenceSubsetting = ownedRendering.ownedReferenceSubsetting in if reference = null then ownedRendering else if not reference.referencedFeature.oclIsKindOf(RenderingUsage) then null else reference.referencedFeature.oclAsType(RenderingUsage) endif owningType.oclIsKindOf(ViewDefinition) or owningType.oclIsKindOf(ViewUsage)
subclass of: Restriction
  cardinality: 1
  on property: ownedRendering
subclass of: Restriction
  cardinality: 1
  on property: referencedRendering
subclass of: FeatureMembership

ownedRendering
type: FunctionalProperty
type: ObjectProperty
comment: The owned RenderingUsage that is either itself the referencedRendering or subsets the referencedRendering.
domain: ViewRenderingMembership
range: RenderingUsage
sub property of: ownedMemberFeature

referencedRendering
type: FunctionalProperty
type: ObjectProperty
comment: The RenderingUsage that is referenced through this ViewRenderingMembership. It is the referencedFeature of the ownedReferenceSubsetting for the ownedRendering, if there is one, and, otherwise, the ownedRendering itself.
domain: ViewRenderingMembership
range: RenderingUsage

ViewUsage
type: Class
comment: A ViewUsage is a usage of a ViewDefinition to specify the generation of a view of the members of a collection of exposedNamespaces. The ViewUsage can satisfy more viewpoints than its definition, and it can specialize the viewRendering specified by its definition. exposedElement = ownedImport->selectByKind(Expose). importedMemberships(Set{}).memberElement-> select(elm | includeAsExposed(elm))-> asOrderedSet() satisfiedViewpoint = ownedRequirement-> selectByKind(ViewpointUsage)-> select(isComposite) viewCondition = ownedMembership-> selectByKind(ElementFilterMembership). condition viewRendering = let renderings: OrderedSet(ViewRenderingMembership) = featureMembership->selectByKind(ViewRenderingMembership) in if renderings->isEmpty() then null else renderings->first().referencedRendering endif featureMembership-> selectByKind(ViewRenderingMembership)-> size() <= 1 specializesFromLibrary('Views::views') owningType <> null and (owningType.oclIsKindOf(ViewDefinition) or owningType.oclIsKindOf(ViewUsage)) implies specializesFromLibrary('Views::View::subviews')
subclass of: PartUsage

exposedElement
is ordered: true
type: ObjectProperty
comment: The Elements that are exposed by this ViewUsage, which are those memberElements of the imported Memberships from all the Expose Relationships that meet all the owned and inherited viewConditions.
domain: ViewUsage
range: Element
sub property of: member

satisfiedViewpoint
is ordered: true
type: ObjectProperty
comment: The nestedRequirements of this ViewUsage that are ViewpointUsages for (additional) viewpoints satisfied by the ViewUsage.
domain: ViewUsage
range: ViewpointUsage
sub property of: nestedRequirement

viewCondition
is ordered: true
type: ObjectProperty
comment: The Expressions related to this ViewUsage by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view.
domain: ViewUsage
range: Expression
sub property of: ownedMember

viewDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The ViewDefinition that is the definition of this ViewUsage.
domain: ViewUsage
range: ViewDefinition
sub property of: partDefinition

viewRendering
type: FunctionalProperty
type: ObjectProperty
comment: The RenderingUsage to be used to render views defined by this ViewUsage, which is the referencedRendering of the ViewRenderingMembership of the ViewUsage.
domain: ViewUsage
range: RenderingUsage

ViewpointDefinition
type: Class
comment: A ViewpointDefinition is a RequirementDefinition that specifies one or more stakeholder concerns that are to be satisfied by creating a view of a model. viewpointStakeholder = framedConcern.featureMemberhsip-> selectByKind(StakeholderMembership). ownedStakeholderParameter specializesFromLibrary('Views::Viewpoint')
subclass of: RequirementDefinition

viewpointStakeholder
is ordered: true
type: ObjectProperty
comment: The PartUsages that identify the stakeholders with concerns framed by this ViewpointDefinition, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointDefinition.
domain: ViewpointDefinition
range: PartUsage

ViewpointUsage
type: Class
comment: A ViewpointUsage is a Usage of a ViewpointDefinition. viewpointStakeholder = framedConcern.featureMemberhsip-> selectByKind(StakeholderMembership). ownedStakeholderParameter specializesFromLibrary('Views::viewpoints') isComposite and owningType <> null and (owningType.oclIsKindOf(ViewDefinition) or owningType.oclIsKindOf(ViewUsage)) implies specializesFromLibrary('Views::View::viewpointSatisfactions')
subclass of: RequirementUsage

viewpointDefinition
type: FunctionalProperty
type: ObjectProperty
comment: The ViewpointDefinition that is the definition of this ViewpointUsage.
domain: ViewpointUsage
range: ViewpointDefinition
sub property of: requirementDefinition

viewpointStakeholder
is ordered: true
type: ObjectProperty
comment: The PartUsages that identify the stakeholders with concerns framed by this ViewpointUsage, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointUsage.
domain: ViewpointUsage
range: PartUsage

VisibilityKind
type: Datatype
comment: VisibilityKind is an enumeration whose literals specify the visibility of a Membership of an Element in a Namespace outside of that Namespace. Note that "visibility" specifically restricts whether an Element in a Namespace may be referenced by name from outside the Namespace and only otherwise restricts access to an Element as provided by specific constraints in the abstract syntax (e.g., preventing the import or inheritance of private Elements).
equivalent class: Datatype
  one of: private
  one of: protected
  one of: public

WhileLoopActionUsage
type: Class
comment: A WhileLoopActionUsage is a LoopActionUsage that specifies that the bodyAction ActionUsage should be performed repeatedly while the result of the whileArgument Expression is true or until the result of the untilArgument Expression (if provided) is true. The whileArgument Expression is evaluated before each (possible) performance of the bodyAction, and the untilArgument Expression is evaluated after each performance of the bodyAction. isSubactionUsage() implies specializesFromLibrary('Actions::Action::whileLoops') untilArgument = let parameter : Feature = inputParameter(3) in if parameter <> null and parameter.oclIsKindOf(Expression) then parameter.oclAsType(Expression) else null endif specializesFromLibrary('Actions::whileLoopActions') whileArgument = let parameter : Feature = inputParameter(1) in if parameter <> null and parameter.oclIsKindOf(Expression) then parameter.oclAsType(Expression) else null endif inputParameters()->size() >= 2
subclass of: Restriction
  cardinality: 1
  on property: whileArgument
subclass of: LoopActionUsage

untilArgument
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result, if false, determines that the bodyAction should continue to be performed. It is the (optional) third owned parameter of the WhileLoopActionUsage.
domain: WhileLoopActionUsage
range: Expression

whileArgument
type: FunctionalProperty
type: ObjectProperty
comment: The Expression whose result, if true, determines that the bodyAction should continue to be performed. It is the first owned parameter of the WhileLoopActionUsage.
domain: WhileLoopActionUsage
range: Expression