From ec53f1a41bf792dab79e5a84a88968ed02e56956 Mon Sep 17 00:00:00 2001
From: khussey
Date: Tue, 27 Mar 2007 03:39:49 +0000
Subject: [173726] Adding convenience factory method for usage dependencies.
---
plugins/org.eclipse.uml2.uml/model/UML.ecore | 16 +-
plugins/org.eclipse.uml2.uml/model/UML.emx | 9 +
plugins/org.eclipse.uml2.uml/model/UML.genmodel | 5 +-
plugins/org.eclipse.uml2.uml/model/UML.merged.uml | 13663 ++++++++++---------
plugins/org.eclipse.uml2.uml/model/UML.uml | 24 +-
.../src/org/eclipse/uml2/uml/NamedElement.java | 15 +-
.../src/org/eclipse/uml2/uml/UMLPackage.java | 3126 ++---
.../uml2/uml/internal/impl/NamedElementImpl.java | 21 +-
.../uml2/uml/internal/impl/UMLFactoryImpl.java | 8 +-
.../uml2/uml/internal/impl/UMLPackageImpl.java | 84 +-
.../org/eclipse/uml2/uml/internal/impl/uml.ecore | 5 +-
.../operations/NamedElementOperations.java | 45 +-
.../eclipse/uml2/uml/util/UMLAdapterFactory.java | 14 +-
.../src/org/eclipse/uml2/uml/util/UMLSwitch.java | 50 +-
.../org/eclipse/uml2/uml/util/UMLValidator.java | 6 +-
15 files changed, 8587 insertions(+), 8504 deletions(-)
diff --git a/plugins/org.eclipse.uml2.uml/model/UML.ecore b/plugins/org.eclipse.uml2.uml/model/UML.ecore
index ee6e8652..ea40efb4 100644
--- a/plugins/org.eclipse.uml2.uml/model/UML.ecore
+++ b/plugins/org.eclipse.uml2.uml/model/UML.ecore
@@ -539,6 +539,12 @@
+
+
+
+
+
+
@@ -5900,6 +5906,11 @@
+
+
+
+
+
@@ -7482,11 +7493,6 @@
-
-
-
-
-
diff --git a/plugins/org.eclipse.uml2.uml/model/UML.emx b/plugins/org.eclipse.uml2.uml/model/UML.emx
index aebc7902..2b2bc9d2 100644
--- a/plugins/org.eclipse.uml2.uml/model/UML.emx
+++ b/plugins/org.eclipse.uml2.uml/model/UML.emx
@@ -772,6 +772,13 @@
+
+
+ Creates a usage between this named element and the specified supplier, owned by this named element's nearest package.
+
+
+
+
@@ -1513,6 +1520,7 @@
+
@@ -1663,4 +1671,5 @@
+
diff --git a/plugins/org.eclipse.uml2.uml/model/UML.genmodel b/plugins/org.eclipse.uml2.uml/model/UML.genmodel
index e164453e..61be1bf9 100644
--- a/plugins/org.eclipse.uml2.uml/model/UML.genmodel
+++ b/plugins/org.eclipse.uml2.uml/model/UML.genmodel
@@ -354,6 +354,9 @@
+
+
+
@@ -2232,6 +2235,7 @@
org.eclipse.ui.views.properties.expert
+
@@ -2766,7 +2770,6 @@
org.eclipse.ui.views.properties.expert
-
diff --git a/plugins/org.eclipse.uml2.uml/model/UML.merged.uml b/plugins/org.eclipse.uml2.uml/model/UML.merged.uml
index 4b214c10..8954d5b1 100644
--- a/plugins/org.eclipse.uml2.uml/model/UML.merged.uml
+++ b/plugins/org.eclipse.uml2.uml/model/UML.merged.uml
@@ -1,169 +1,169 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
An integer is a primitive type representing integer values.
-
+
A Boolean type is used for logical expression, consisting of the predefined values true and false.
-
+
A string is a sequence of characters in some suitable character set used to display information about the model. Character sets may include non-Roman alphabets and characters.
-
+
An unlimited natural is a primitive type representing unlimited natural values.
-
-
+
+
A comment is a textual annotation that can be attached to a set of elements.
-
-
-
+
+
+
Specifies a string that is the comment.
-
-
+
+
-
-
+
+
References the Element(s) being commented.
-
-
+
+
-
+
A directed relationship represents a relationship between a collection of source model elements and a collection of target model elements.
-
-
-
+
+
+
Specifies the sources of the DirectedRelationship.
-
-
+
+
-
-
+
+
Specifies the targets of the DirectedRelationship.
-
-
+
+
-
-
+
+
A literal specification identifies a literal constant being modeled.
-
+
-
+
A literal integer is a specification of an integer value.
-
-
-
+
+
+
The specified Integer value.
-
+
-
-
+
+
The query isComputable() is redefined to be true.
-
-
+
+
OCL
result = true
-
+
-
-
+
+
The query integerValue() gives the value.
-
-
+
+
OCL
result = value
-
+
-
+
A literal string is a specification of a string value.
-
-
-
+
+
+
The specified String value.
-
-
+
+
@@ -171,446 +171,446 @@
-
-
+
+
The query isComputable() is redefined to be true.
-
-
+
+
OCL
result = true
-
+
-
-
+
+
The query stringValue() gives the value.
-
-
+
+
OCL
result = value
-
+
-
+
A literal Boolean is a specification of a Boolean value.
-
-
-
+
+
+
The specified Boolean value.
-
+
-
-
+
+
The query isComputable() is redefined to be true.
-
-
+
+
OCL
result = true
-
+
-
-
+
+
The query booleanValue() gives the value.
-
-
+
+
OCL
result = value
-
+
-
-
+
+
A literal null specifies the lack of a value.
-
-
-
+
+
+
The query isComputable() is redefined to be true.
-
-
+
+
OCL
result = true
-
+
-
-
+
+
The query isNull() returns true.
-
-
+
+
OCL
result = true
-
+
-
-
+
+
A constraint is a condition or restriction expressed in natural language text or in a machine readable language for the purpose of declaring some of the semantics of an element.
-
-
+
+
A constraint cannot be applied to itself.
-
+
OCL
not constrainedElement->includes(self)
-
-
+
+
The value specification for a constraint must evaluate to a Boolean value.
-
+
OCL
self.specification().booleanValue().isOclKindOf(Boolean)
-
-
+
+
The value specification for a constraint must evaluate to a Boolean value.
-
+
OCL
true
-
-
+
+
Evaluating the value specification for a constraint must not have side effects.
-
+
OCL
true
-
-
+
+
A constraint cannot be applied to itself.
-
+
OCL
not constrainedElement->includes(self)
-
-
-
+
+
+
The ordered set of Elements referenced by this Constraint.
-
-
+
+
-
-
+
+
A condition that must be true when evaluated in order for the constraint to be satisfied.
-
-
+
+
-
-
+
+
Specifies the namespace that owns the NamedElement.
-
-
+
+
-
+
An element import identifies an element in another package, and allows the element to be referenced using its name without a qualifier.
-
-
+
+
The visibility of an ElementImport is either public or private.
-
+
OCL
self.visibility = #public or self.visibility = #private
-
-
+
+
An importedElement has either public visibility or no visibility at all.
-
+
OCL
self.importedElement.visibility.notEmpty() implies self.importedElement.visibility = #public
-
-
-
+
+
+
Specifies the visibility of the imported PackageableElement within the importing Package. The default visibility is the same as that of the imported element. If the imported element does not have a visibility, it is possible to add visibility to the element import.
-
+
-
-
+
+
Specifies the name that should be added to the namespace of the importing package in lieu of the name of the imported packagable element. The aliased name must not clash with any other member name in the importing package. By default, no alias is used.
-
-
+
+
-
-
+
+
Specifies the PackageableElement whose name is to be added to a Namespace.
-
-
+
+
-
-
+
+
Specifies the Namespace that imports a PackageableElement from another Package.
-
-
+
+
-
-
+
+
The query getName() returns the name under which the imported PackageableElement will be known in the importing namespace.
-
-
+
+
OCL
result = if self.alias->notEmpty() then
self.alias
else
self.importedElement.name
endif
-
+
-
-
+
+
A typed element is a kind of named element that represents an element with a type.
-
+
A typed element has a type.
-
-
-
+
+
+
This information is derived from the return result for this Operation.
-
+
The type of the TypedElement.
-
-
+
+
-
-
+
+
A feature declares a behavioral or structural characteristic of instances of classifiers.
-
-
-
+
+
+
Specifies whether this feature characterizes individual instances classified by the classifier (false) or the classifier itself (true).
-
+
-
-
+
+
The Classifiers that have this Feature as a feature.
-
-
+
+
-
-
+
+
A redefinable element is an element that, when defined in the context of a classifier, can be redefined more specifically or differently in the context of another classifier that specializes (directly or indirectly) the context classifier.
-
-
+
+
At least one of the redefinition contexts of the redefining element must be a specialization of at least one of the redefinition contexts for each redefined element.
-
+
OCL
self.redefinedElement->forAll(e | self.isRedefinitionContextValid(e))
-
-
+
+
A redefining element must be consistent with each redefined element.
-
+
OCL
self.redefinedElement->forAll(re | re.isConsistentWith(self))
-
-
-
+
+
+
Indicates whether it is possible to further specialize a RedefinableElement. If the value is true, then it is not possible to further specialize the RedefinableElement.
-
+
-
-
+
+
The redefinable element that is being redefined by this element.
-
-
+
+
-
-
+
+
References the contexts that this element may be redefined from.
-
-
+
+
-
-
+
+
The query isConsistentWith() specifies, for any two RedefinableElements in a context in which redefinition is possible, whether redefinition would be logically consistent. By default, this is false; this operation must be overridden for subclasses of RedefinableElement to define the consistency conditions.
-
-
+
+
OCL
redefinee.isRedefinitionContextValid(self)
-
-
+
+
OCL
result = false
-
-
+
+
-
-
+
+
The query isRedefinitionContextValid() specifies whether the redefinition contexts of this RedefinableElement are properly related to the redefinition contexts of the specified RedefinableElement to allow this element to redefine the other. By default at least one of the redefinition contexts of this element must be a specialization of at least one of the redefinition contexts of the specified element.
-
-
+
+
OCL
result = redefinitionContext->exists(c | c.allParents()->includes(redefined.redefinitionContext)))
-
-
+
+
-
-
+
+
A structural feature is a typed feature of a classifier that specifies the structure of instances of the classifier.
-
+
By specializing multiplicity element, it supports a multiplicity that specifies valid cardinalities for the collection of values associated with an instantiation of the structural feature.
-
-
-
-
-
+
+
+
+
+
States whether the feature's value may be modified by a client.
-
+
-
-
+
+
A slot specifies that an entity modeled by an instance specification has a value or values for a specific structural feature.
-
-
-
+
+
+
The instance specification that owns this slot.
-
-
+
+
-
-
+
+
The structural feature that specifies the values that may be held by the slot.
-
-
+
+
-
-
+
+
The value or values corresponding to the defining feature for the owning instance specification.
-
-
+
+
-
+
A package import is a relationship that allows the use of unqualified names to refer to package members from other namespaces.
-
-
+
+
The visibility of a PackageImport is either public or private.
-
+
OCL
self.visibility = #public or self.visibility = #private
-
-
-
+
+
+
Specifies the visibility of the imported PackageableElements within the importing Namespace, i.e., whether imported elements will in turn be visible to other packages that use that importingPackage as an importedPackage. If the PackageImport is public, the imported elements will be visible outside the package, while if it is private they will not.
-
+
-
-
+
+
Specifies the Namespace that imports the members from a Package.
-
-
+
+
-
-
+
+
Specifies the Package whose members are imported into a Namespace.
-
-
+
+
-
+
A data type is a type whose instances are identified only by their value. A data type may contain attributes to support the modeling of structured data types.
-
-
-
+
+
+
The Attributes owned by the DataType.
-
-
+
+
-
-
+
+
The Operations owned by the DataType.
-
-
+
+
@@ -650,133 +650,133 @@
-
-
+
+
The inherit operation is overridden to exclude redefined properties.
-
-
+
+
OCL
result = inhs->excluding(inh | ownedMember->select(oclIsKindOf(RedefinableElement))->select(redefinedElement->includes(inh)))
-
-
-
+
+
+
-
-
-
+
+
+
-
+
An enumeration is a data type whose values are enumerated in the model as enumeration literals.
-
-
-
+
+
+
The ordered set of literals for this Enumeration.
-
-
+
+
-
+
An enumeration literal is a user-defined data value for an enumeration.
-
-
-
+
+
+
The Enumeration that this EnumerationLiteral is a member of.
-
-
+
+
-
+
A primitive type defines a predefined data type, without any relevant substructure (i.e., it has no parts in the context of UML). A primitive datatype may have an algebra and operations defined outside of UML, for example, mathematically.
-
+
-
+
An association describes a set of tuples whose values refer to typed instances. An instance of an association is called a link.
-
-
+
+
An association specializing another association has the same number of ends as the other association.
-
+
OCL
self.parents()->forAll(p | p.memberEnd.size() = self.memberEnd.size())
-
-
+
+
When an association specializes another association, every end of the specific association corresponds to an end of the general association, and the specific end reaches the same type or a subtype of the more general end.
-
+
OCL
true
-
-
+
+
Only binary associations can be aggregations.
-
+
OCL
self.memberEnd->exists(aggregation <> Aggregation::none) implies self.memberEnd->size() = 2
-
-
+
+
Association ends of associations with more than two ends must be owned by the association.
-
+
OCL
if memberEnd->size() > 2 then ownedEnd->includesAll(memberEnd)
-
-
-
-
+
+
+
+
Specifies whether the association is derived from other model elements such as other associations or constraints.
-
+
-
-
+
+
The ends that are owned by the association itself.
-
-
+
+
-
-
+
+
References the classifiers that are used as types of the ends of the association.
-
-
+
+
-
-
+
+
Each end represents participation of instances of the classifier connected to the end in links of the association.
-
-
+
+
-
-
+
+
The navigable ends that are owned by the association itself.
-
-
+
+
@@ -784,124 +784,124 @@
-
-
+
+
endType is derived from the types of the member ends.
-
-
+
+
OCL
result = self.memberEnd->collect(e | e.type)
-
-
-
+
+
+
-
+
Relationship is an abstract concept that specifies some kind of relationship between elements.
-
-
-
+
+
+
Specifies the elements related by the Relationship.
-
-
+
+
-
-
+
+
A package merge defines how the contents of one package are extended by the contents of another package.
-
-
-
+
+
+
References the Package that is being extended with the contents of the merged package of the PackageMerge.
-
-
+
+
-
-
+
+
References the Package that is to be merged with the receiving package of the PackageMerge.
-
-
+
+
-
+
An instance value is a value specification that identifies an instance.
-
-
-
+
+
+
The instance that is the specified value.
-
-
+
+
-
+
A literal unlimited natural is a specification of an unlimited natural number.
-
-
-
+
+
+
The specified UnlimitedNatural value.
-
+
-
-
+
+
The query isComputable() is redefined to be true.
-
-
+
+
OCL
result = true
-
+
-
-
+
+
The query unlimitedValue() gives the value.
-
-
+
+
OCL
result = value
-
+
-
+
A type is a named element that is used as the type for a typed element. A type can be contained in a package.
-
+
A type constrains the values represented by a typed element.
-
-
-
+
+
+
Specifies the owning package of this classifier, if any.
-
-
+
+
@@ -929,479 +929,479 @@
-
-
+
+
The query conformsTo() gives true for a type that conforms to another. By default, two types do not conform to each other. This query is intended to be redefined for specific conformance situations.
-
-
+
+
OCL
result = false
-
-
+
+
-
-
+
+
An expression is a structured tree of symbols that denotes a (possibly empty) set of values when evaluated in a context.
-
+
An expression represents a node in an expression tree, which may be non-terminal or terminal. It defines a symbol, and has a possibly empty sequence of operands which are value specifications.
-
-
-
+
+
+
The symbol associated with the node in the expression tree.
-
-
+
+
-
-
+
+
Specifies a sequence of operands.
-
-
+
+
-
+
AggregationKind is an enumeration type that specifies the literals for defining the kind of aggregation of a property.
-
-
+
+
Indicates that the property has no aggregation.
-
-
+
+
Indicates that the property has a shared aggregation.
-
-
+
+
Indicates that the property is aggregated compositely, i.e., the composite object has responsibility for the existence and storage of the composed objects (parts).
-
-
+
+
Parameter direction kind is an enumeration type that defines literals used to specify direction of parameters.
-
-
+
+
Indicates that parameter values are passed into the behavioral element by the caller.
-
-
+
+
Indicates that parameter values are passed into a behavioral element by the caller and then back out to the caller from the behavioral element.
-
-
+
+
Indicates that parameter values are passed from a behavioral element out to the caller.
-
-
+
+
Indicates that parameter values are passed as return values from a behavioral element back to the caller.
-
+
VisibilityKind is an enumeration type that defines literals to determine the visibility of elements in a model.
-
-
+
+
The query bestVisibility() examines a set of VisibilityKinds, and returns public as the preferred visibility.
-
-
+
+
OCL
pre: not vis->includes(#protected) and not vis->includes(#package)
-
-
+
+
OCL
result = if vis->includes(#public) then #public else #private endif
-
-
-
-
+
+
+
+
-
-
+
+
A public element is visible to all elements that can access the contents of the namespace that owns it.
-
-
+
+
A private element is only visible inside the namespace that owns it.
-
-
+
+
A protected element is visible to elements that have a generalization relationship to the namespace that owns it.
-
-
+
+
A package element is owned by a namespace that is not a package, and is visible to elements that are in the same package as its owning namespace. Only named elements that are not owned by packages can be marked as having package visibility. Any element marked as having package visibility is visible to all elements within the nearest enclosing package (given that other owning elements have proper visibility). Outside the nearest enclosing package, an element marked as having package visibility is not visible.
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
+
An opaque expression is an uninterpreted textual statement that denotes a (possibly empty) set of values when evaluated in a context.
-
+
Provides a mechanism for precisely defining the behavior of an opaque expression. An opaque expression is defined by a behavior restricted to return one result.
-
-
+
+
If the language attribute is not empty, then the size of the body and language arrays must be the same.
-
+
OCL
language->notEmpty() implies (body->size() = language->size())
-
-
+
+
The behavior may only have return result parameters.
-
+
OCL
self.behavior.notEmpty() implies
self.behavior.ownedParameters->select(p | p.direction<>#return)->isEmpty()
-
-
+
+
The behavior must have exactly one return result parameter.
-
+
OCL
self.behavior.notEmpty() implies
self.behavior.ownedParameter->select(p | p.direction=#return)->size() = 1
-
+
-
+
The text of the expression, possibly in multiple languages.
-
-
+
+
-
-
+
+
Specifies the languages in which the expression is stated. The interpretation of the expression body depends on the languages. If the languages are unspecified, they might be implicit from the expression body or the context. Languages are matched to body strings by order.
-
-
+
+
-
-
+
+
Restricts an opaque expression to return exactly one return result. When the invocation of the opaque expression completes, a single set of values is returned to its owner. This association is derived from the single return result parameter of the associated behavior.
-
-
+
+
-
-
+
+
Specifies the behavior of the opaque expression.
-
-
+
+
@@ -1412,481 +1412,481 @@
-
-
+
+
The query value() gives an integer value for an expression intended to produce one.
-
-
+
+
OCL
self.isIntegral()
-
-
+
+
OCL
true
-
+
-
-
+
+
The query isIntegral() tells whether an expression is intended to produce an integer.
-
-
+
+
OCL
result = false
-
+
-
-
+
+
The query isPositive() tells whether an integer expression has a positive value.
-
-
+
+
OCL
self.isIntegral()
-
-
+
+
OCL
result = false
-
+
-
-
+
+
The query isNonNegative() tells whether an integer expression has a non-negative value.
-
-
+
+
OCL
self.isIntegral()
-
-
+
+
OCL
result = false
-
+
-
+
An behavior with implementation-specific semantics.
-
+
-
+
Specifies the behavior in one or more languages.
-
-
+
+
-
-
+
+
Languages the body strings use in the same order as the body strings.
-
-
+
+
-
-
+
+
A function behavior is an opaque behavior that does not access or modify any objects or other external data.
-
-
+
+
A function behavior has at least one output parameter.
-
+
OCL
self.ownedParameters->
select(p | p.direction=#out or p.direction=#inout or p.direction=#return)->size() >= 1
-
-
+
+
The types of parameters are all data types, which may not nest anything but other datatypes.
-
+
OCL
def: hasAllDataTypeAttributes(d : DataType) : Boolean =
d.ownedAttribute->forAll(a |
a.type.oclIsTypeOf(DataType) and
hasAllDataTypeAttributes(a.type))
self.ownedParameters->forAll(p | p.type.notEmpty() and
p.oclIsTypeOf(DataType) and hasAllDataTypeAttributes(p))
-
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
+
An action with implementation-specific semantics.
-
+
-
+
Specifies the action in one or more languages.
-
-
+
+
-
-
+
+
Languages the body strings use, in the same order as the body strings
-
-
+
+
-
-
+
+
Provides input to the action.
-
-
+
+
-
-
+
+
Takes output from the action.
-
-
+
+
-
-
+
+
CallAction is an abstract class for actions that invoke behavior and receive return values.
-
-
+
+
Only synchronous call actions can have result pins.
-
+
OCL
true
-
-
+
+
The number and order of argument pins must be the same as the number and order of parameters of the invoked behavior or behavioral feature. Pins are matched to parameters by order.
-
+
OCL
true
-
-
+
+
The type, ordering, and multiplicity of an argument pin must be the same as the corresponding parameter of the behavior or behavioral feature.
-
+
OCL
true
-
-
-
+
+
+
If true, the call is synchronous and the caller waits for completion of the invoked behavior.
If false, the call is asynchronous and the caller proceeds immediately and does not expect a return values.
-
+
-
-
+
+
A list of output pins where the results of performing the invocation are placed.
-
-
+
+
-
-
+
+
A send signal action is an action that creates a signal instance from its inputs, and transmits it to the target object, where it may cause the firing of a state machine transition or the execution of an activity. The argument values are available to the execution of associated behaviors. The requestor continues execution immediately. Any reply message is ignored and is not transmitted to the requestor. If the input is already a signal instance, use a send object action.
-
-
+
+
The number and order of argument pins must be the same as the number and order of attributes in the signal.
-
+
OCL
true
-
-
+
+
The type, ordering, and multiplicity of an argument pin must be the same as the corresponding attribute of the signal.
-
+
OCL
true
-
-
-
+
+
+
The target object to which the signal is sent.
-
-
+
+
-
-
+
+
The type of signal transmitted to the target object.
-
-
+
+
-
-
+
+
A call operation action is an action that transmits an operation call request to the target object, where it may cause the invocation of associated behavior. The argument values of the action are available to the execution of the invoked behavior. If the action is marked synchronous, the execution of the call operation action waits until the execution of the invoked behavior completes and a reply transmission is returned to the caller; otherwise execution of the action is complete when the invocation of the operation is established and the execution of the invoked operation proceeds concurrently with the execution of the calling behavior. Any values returned as part of the reply transmission are put on the result output pins of the call operation action. Upon receipt of the reply transmission, execution of the call operation action is complete.
-
-
+
+
The number of argument pins and the number of owned parameters of the operation of type in and in-out must be equal.
-
+
OCL
true
-
-
+
+
The number of result pins and the number of owned parameters of the operation of type return, out, and in-out must be equal.
-
+
OCL
true
-
-
+
+
The type, ordering, and multiplicity of an argument or result pin is derived from the corresponding owned parameter of the operation.
-
+
OCL
true
-
-
+
+
The type of the target pin must be the same as the type that owns the operation.
-
+
OCL
true
-
-
-
+
+
+
The operation to be invoked by the action execution.
-
-
+
+
-
-
+
+
The target object to which the request is sent. The classifier of the target object is used to dynamically determine a behavior to invoke. This object constitutes the context of the execution of the operation.
-
-
+
+
-
-
+
+
A call behavior action is a call action that invokes a behavior directly rather than invoking a behavioral feature that, in turn, results in the invocation of that behavior. The argument values of the action are available to the execution of the invoked behavior. For synchronous calls the execution of the call behavior action waits until the execution of the invoked behavior completes and a result is returned on its output pin. The action completes immediately without a result, if the call is asynchronous. In particular, the invoked behavior may be an activity.
-
-
+
+
The number of argument pins and the number of parameters of the behavior of type in and in-out must be equal.
-
+
OCL
true
-
-
+
+
The number of result pins and the number of parameters of the behavior of type return, out, and in-out must be equal.
-
+
OCL
true
-
-
+
+
The type, ordering, and multiplicity of an argument or result pin is derived from the corresponding parameter of the behavior.
-
+
OCL
true
-
-
-
+
+
+
The invoked behavior. It must be capable of accepting and returning control.
-
-
+
+
-
+
A multiplicity is a definition of an inclusive interval of non-negative integers beginning with a lower bound and ending with a (possibly infinite) upper bound. A multiplicity element embeds this information to specify the allowable cardinalities for an instantiation of this element.
-
-
+
+
A multiplicity must define at least one valid cardinality that is greater than zero.
-
+
OCL
upperBound()->notEmpty() implies upperBound() > 0
-
-
+
+
The lower bound must be a non-negative integer literal.
-
+
OCL
lowerBound()->notEmpty() implies lowerBound() >= 0
-
-
+
+
The upper bound must be greater than or equal to the lower bound.
-
+
OCL
(upperBound()->notEmpty() and lowerBound()->notEmpty()) implies upperBound() >= lowerBound()
-
-
+
+
If a non-literal ValueSpecification is used for the lower or upper bound, then evaluating that specification must not have side effects.
-
+
OCL
true
-
-
+
+
If a non-literal ValueSpecification is used for the lower or upper bound, then that specification must be a constant expression.
-
+
OCL
true
-
-
-
+
+
+
For a multivalued multiplicity, this attribute specifies whether the values in an instantiation of this element are sequentially ordered.
-
+
-
-
+
+
For a multivalued multiplicity, this attributes specifies whether the values in an instantiation of this element are unique.
-
+
-
-
+
+
Specifies the upper bound of the multiplicity interval.
-
-
-
+
+
+
-
-
+
+
Specifies the lower bound of the multiplicity interval.
-
-
-
+
+
+
-
-
+
+
The specification of the upper bound for this multiplicity.
-
-
+
+
-
-
+
+
The specification of the lower bound for this multiplicity.
-
-
+
+
@@ -1894,441 +1894,441 @@ If false, the call is asynchronous and the caller proceeds immediately and does
-
-
+
+
The derived lower attribute must equal the lowerBound.
-
-
+
+
OCL
result = lowerBound()
-
+
-
-
+
+
The derived upper attribute must equal the upperBound.
-
-
+
+
OCL
result = upperBound()
-
+
-
-
+
+
The query isMultivalued() checks whether this multiplicity has an upper bound greater than one.
-
-
+
+
OCL
upperBound()->notEmpty()
-
-
+
+
OCL
result = upperBound() > 1
-
+
-
-
+
+
The query includesCardinality() checks whether the specified cardinality is valid for this multiplicity.
-
-
+
+
OCL
upperBound()->notEmpty() and lowerBound()->notEmpty()
-
-
+
+
OCL
result = (lowerBound() <= C) and (upperBound() >= C)
-
-
+
+
-
-
+
+
The query includesMultiplicity() checks whether this multiplicity includes all the cardinalities allowed by the specified multiplicity.
-
-
+
+
OCL
self.upperBound()->notEmpty() and self.lowerBound()->notEmpty() and M.upperBound()->notEmpty() and M.lowerBound()->notEmpty()
-
-
+
+
OCL
result = (self.lowerBound() <= M.lowerBound()) and (self.upperBound() >= M.upperBound())
-
-
+
+
-
-
+
+
The query lowerBound() returns the lower bound of the multiplicity as an integer.
-
-
+
+
OCL
result = if lowerValue->isEmpty() then 1 else lowerValue.integerValue() endif
-
+
-
-
+
+
The query upperBound() returns the upper bound of the multiplicity for a bounded multiplicity as an unlimited natural.
-
-
+
+
OCL
result = if upperValue->isEmpty() then 1 else upperValue.unlimitedValue() endif
-
+
-
-
+
+
The operation compatibleWith takes another multiplicity as input. It checks if one multiplicity is compatible with another.
-
-
+
+
OCL
result = Integer.allInstances()->forAll(i : Integer | self.includesCardinality(i) implies other.includesCardinality(i))
-
-
+
+
-
-
+
+
The operation is determines if the upper and lower bound of the ranges are the ones given.
-
-
+
+
OCL
result = (lowerbound = self.lowerbound and upperbound = self.upperbound)
-
-
-
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
+
+
+
A sequence node is a structured activity node that executes its actions in order.
-
-
-
+
+
+
An ordered set of executable nodes.
-
-
+
+
-
-
+
+
An input pin is a pin that holds input values to be consumed by an action.
-
-
+
+
Input pins may have outgoing edges only when they are on actions that are structured nodes, and these edges must target a node contained by the structured node.
-
+
OCL
true
-
+
-
-
+
+
An output pin is a pin that holds output values produced by an action.
-
-
+
+
Output pins may have incoming edges only when they are on actions that are structured nodes, and these edges may not target a node contained by the structured node.
-
+
OCL
true
-
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
+
+
+
A usage is a relationship in which one element requires another element (or set of elements) for its full implementation or operation. A usage is a dependency in which the client requires the presence of the supplier.
-
+
-
-
+
+
An abstraction is a relationship that relates two elements or sets of elements that represent the same concept at different levels of abstraction or from different viewpoints.
-
-
-
+
+
+
An composition of an Expression that states the abstraction relationship between the supplier and the client. In some cases, such as Derivation, it is usually formal and unidirectional; in other cases, such as Trace, it is usually informal and bidirectional. The mapping expression is optional and may be omitted if the precise relationship between the elements is not specified.
-
-
+
+
-
+
A dependency is a relationship that signifies that a single or a set of model elements requires other model elements for their specification or implementation. This means that the complete semantics of the depending elements is either semantically or structurally dependent on the definition of the supplier element(s).
-
-
-
-
+
+
+
+
The element(s) independent of the client element(s), in the same respect and the same dependency relationship. In some directed dependency relationships (such as Refinement Abstractions), a common convention in the domain of class-based OO software is to put the more abstract element in this role. Despite this convention, users of UML may stipulate a sense of dependency suitable for their domain, which makes a more abstract element dependent on that which is more specific.
-
-
+
+
-
-
+
+
The element(s) dependent on the supplier element(s). In some cases (such as a Trace Abstraction) the assignment of direction (that is, the designation of the client element) is at the discretion of the modeler, and is a stipulation.
-
-
+
+
-
-
+
+
Realization is a specialized abstraction relationship between two sets of model elements, one representing a specification (the supplier) and the other represents an implementation of the latter (the client). Realization can be used to model stepwise refinement, optimizations, transformations, templates, model synthesis, framework composition, etc.
-
+
-
-
+
+
A substitution is a relationship between two classifiers signifies that the substituting classifier complies with the contract specified by the contract classifier. This implies that instances of the substituting classifier are runtime substitutable where instances of the contract classifier are expected.
-
-
-
+
+
+
The contract with which the substituting classifier complies.
-
-
+
+
-
-
+
+
Instances of the substituting classifier are runtime substitutable where instances of the contract classifier are expected.
-
-
+
+
-
+
A namespace is an element in a model that contains a set of named elements that can be identified by name.
-
-
+
+
All the members of a Namespace are distinguishable within it.
-
+
OCL
membersAreDistinguishable()
-
-
-
+
+
+
References the ElementImports owned by the Namespace.
-
-
+
+
-
-
+
+
References the PackageImports owned by the Namespace.
-
-
+
+
-
-
+
+
Specifies a set of Constraints owned by this Namespace.
-
-
+
+
-
-
+
+
A collection of NamedElements identifiable within the Namespace, either by being owned or by being introduced by importing or inheritance.
-
-
+
+
-
-
+
+
References the PackageableElements that are members of this Namespace as a result of either PackageImports or ElementImports.
-
-
+
+
-
-
+
+
A collection of NamedElements owned by the Namespace.
-
-
+
+
@@ -2364,202 +2364,202 @@ If false, the call is asynchronous and the caller proceeds immediately and does
-
-
+
+
The importedMember property is derived from the ElementImports and the PackageImports. References the PackageableElements that are members of this Namespace as a result of either PackageImports or ElementImports.
-
-
+
+
OCL
result = self.importMembers(self.elementImport.importedElement.asSet()-
>union(self.packageImport.importedPackage->collect(p | p.visibleMembers())))
-
-
-
+
+
+
-
-
+
+
The query getNamesOfMember() takes importing into account. It gives back the set of names that an element would have in an importing namespace, either because it is owned, or if not owned then imported individually, or if not individually then from a package.
-
+
The query getNamesOfMember() gives a set of all of the names that a member would have in a Namespace. In general a member can have multiple names in a Namespace if it is imported more than once with different aliases. The query takes account of importing. It gives back the set of names that an element would have in an importing namespace, either because it is owned, or if not owned then imported individually, or if not individually then from a package.
-
-
+
+
OCL
result = if self.ownedMember ->includes(element)
then Set{}->include(element.name)
else let elementImports: ElementImport = self.elementImport->select(ei | ei.importedElement = element) in
if elementImports->notEmpty()
then elementImports->collect(el | el.getName())
else self.packageImport->select(pi | pi.importedPackage.visibleMembers()->includes(element))-> collect(pi | pi.importedPackage.getNamesOfMember(element))
endif
endif
-
-
-
+
+
+
-
+
-
-
+
+
The Boolean query membersAreDistinguishable() determines whether all of the namespace's members are distinguishable within it.
-
-
+
+
OCL
result = self.member->forAll( memb |
self.member->excluding(memb)->forAll(other |
memb.isDistinguishableFrom(other, self)))
-
+
-
-
+
+
The query importMembers() defines which of a set of PackageableElements are actually imported into the namespace. This excludes hidden ones, i.e., those which have names that conflict with names of owned members, and also excludes elements which would have the same name when imported.
-
-
+
+
OCL
result = self.excludeCollisions(imps)->select(imp | self.ownedMember->forAll(mem |
mem.imp.isDistinguishableFrom(mem, self)))
-
-
-
+
+
+
-
-
-
+
+
+
-
-
+
+
The query excludeCollisions() excludes from a set of PackageableElements any that would not be distinguishable from each other in this namespace.
-
-
+
+
OCL
result = imps->reject(imp1 | imps.exists(imp2 | not imp1.isDistinguishableFrom(imp2, self)))
-
-
-
+
+
+
-
-
-
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
Indicates the dependencies that reference the supplier.
-
-
+
+
-
-
+
+
-
+
An interface realization is a specialized realization relationship between a classifier and an interface. This relationship signifies that the realizing classifier conforms to the contract specified by the interface.
-
-
-
+
+
+
References the Interface specifying the conformance contract.
-
-
+
+
-
-
+
+
References the BehavioredClassifier that owns this Interfacerealization (i.e., the classifier that realizes the Interface to which it points).
-
-
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
-
+
A structured classifier is an abstract metaclass that represents any classifier whose behavior can be fully or partly described by the collaboration of owned or referenced instances.
-
-
+
+
The multiplicities on connected elements must be consistent.
-
+
OCL
true
-
-
-
+
+
+
References the properties owned by the classifier.
-
-
+
+
-
-
+
+
References the properties specifying instances that the classifier owns by composition. This association is derived, selecting those owned properties where isComposite is true.
-
-
+
+
-
-
+
+
References the roles that instances may play in this classifier.
-
-
+
+
-
-
+
+
References the connectors owned by the classifier.
-
-
+
+
@@ -2578,400 +2578,400 @@ If false, the call is asynchronous and the caller proceeds immediately and does
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
-
-
+
+
Variables are elements for passing data between actions indirectly. A local variable stores values shared by the actions within a structured activity group but not accessible outside it. The output of an action may be written to a variable and read for the input to a subsequent action, which is effectively an indirect data flow path. Because there is no predefined relationship between actions that read and write variables, these actions must be sequenced by control flows to prevent race conditions that may occur between actions that read or write the same variable.
-
+
A variable is considered a connectable element.
-
-
+
+
A variable is owned by a StructuredNode or Activity, but not both.
-
+
OCL
true
-
-
-
-
+
+
+
+
A structured activity node that owns the variable.
-
-
+
+
-
-
+
+
An activity that owns the variable.
-
-
+
+
-
-
+