Rules

• Name: The value can be anything.

  The name of the item.

• Keywords: The value can be anything.

  A keyword is a lightweight variant of a stereotype to extend the semantics of a model element. As opposite of stereotypes, keywords does not have do be defined in a profile.

  If several keywords are given, they should be separated by commas.

• Stereotypes: The value can be anything.

  A stereotype defines how a model element may be extended, and enables the use of platform or domain specific terminology or notation in place of, or in addition to, the ones used for the extended metaclass.

  Stereotypes should be given in the format 'profile::stererotype'. Stereotypes should be separated by commas.

• Documentation: The value can be anything.

  A textual description of the element.

• Type: The value shall be empty or a: Activity or Actor or Artifact or Association or Class or Collaboration or Communication Path or Component or Data Type or Deployment Specification or Device or Enumeration or Execution Environment or Extension or Information Item or Interaction or Interface or Node or Opaque Behavior or Primitive Type or Protocol or Protocol State Machine or Signal or State Machine or Stereotype or Use Case.

  The type of the element.

• Default Value: The value can be anything.

  A String that is evaluated to give a default value for the Property when an object of the owning Classifier is instantiated.

• Multiplicity: The value can be anything.

  Specifies the lower and upper bound of the multiplicity interval.

• Visibility: The value shall be a valid literal from the enumeration Visibility Kind.

  Determines where the item appears within different Namespaces within the overall model, and its accessibility.

• Aggregation: The value shall be a valid literal from the enumeration Aggregation Kind.

  Specifies the kind of aggregation that applies to the Property.

• Behavior: The value shall be non-empty.

  Specifies whether requests arriving at this port are sent to the classifier behavior of this classifier.

  Such ports are referred to as behavior port. Any invocation of a behavioral feature targeted at a behavior port will be handled by the instance of the owning classifier itself, rather than by any instances that this classifier may contain.

• Derived: The value shall be non-empty.

  If isDerived is true, the value of the attribute is derived from information elsewhere. Specifies whether the Property is derived, i.e., whether its value or values can be computed from other information.

• Derived Union: The value shall be non-empty.

  Specifies whether the property is derived as the union of all of the properties that are constrained to subset it.

• Leaf: The value shall be non-empty.

  Indicates whether it is possible to further specialize an item. If the value is true, then it is not possible to further specialize the item.

• Navigable: The value can be anything.

  A property is navigable if it is possible to navigate from an instance of the owner of the property to an instance of the type of the property.

• Ordered: The value shall be non-empty.

  For a multivalued multiplicity, this attribute specifies whether the values in an instantiation of this element are sequentially ordered.

• Read Only: The value shall be non-empty.

  States whether the attribute's value may be modified by a client.

• Service: The value shall be non-empty.

  If true indicates that this port is used to provide the published functionality of a classifier.

  If false, this port is used to implement the classifier but is not part of the essential externally-visible functionality of the classifier and can, therefore, be altered or deleted along with the internal implementation of the classifier and other properties that are considered part of its implementation.

• Static: The value can be anything.

  Specifies whether this feature characterizes individual instances classified by the classifier (false) or the classifier itself (true).

• Unique: The value shall be non-empty.

  For a multivalued multiplicity, this attributes specifies whether the values in an instantiation of this element are unique.

An element of one of the following kinds:

• Activity (Activity)

  An activity is the specification of parameterized behavior as the coordinated sequencing of subordinate units whose individual elements are actions.

• Artifact (Artifact)

  An artifact is the specification of a physical piece of information that is used or produced by a software development process, or by deployment and operation of a system.

  Examples of artifacts include model files, source files, scripts, and binary executable files, a table in a database system, a development deliverable, or a word-processing document, a mail message. An artifact is the source of a deployment to a node.

• Class (Class)

  A class describes a set of objects that share the same specifications of features, constraints, and semantics.

  A class may be designated as active (i.e., each of its instances having its own thread of control) or passive (i.e., each of its instances executing within the context of some other object).

  A class may also specify which signals the instances of this class handle. A class has the capability to have an internal structure and ports. Class has derived association that indicates how it may be extended through one or more stereotypes. Stereotype is the only kind of metaclass that cannot be extended by stereotypes.

• Collaboration (Collaboration)

  A collaboration defines a set of co-operating roles used collectively to illustrate a specific functionality.

  A collaboration should only show the roles and attributes required to accomplish its defined task or function. Isolating the primary roles is an exercise in simplifying the structure and clarifying the behavior, and also provides for re-use. A collaboration often implements a pattern.

• Component (Component)

  A component represents a modular part of a system that encapsulates its contents and whose manifestation is replaceable within its environment.

  In the namespace of a component, all model elements that are involved in or related to its definition are either owned or imported explicitly. This may include, for example, use cases and dependencies (e.g. mappings), packages, components, and artifacts.

• Data Type (Data Type)

  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.

• Deployment Specification (Deployment Specification)

  A deployment specification specifies a set of properties that determine execution parameters of a component artifact that is deployed on a node.

  A deployment specification can be aimed at a specific type of container. An artifact that reifies or implements deployment specification properties is a deployment descriptor.

• Device (Device)

  A device is a physical computational resource with processing capability upon which artifacts may be deployed for execution.

  Devices may be complex (i.e., they may consist of other devices).

• Enumeration (Enumeration)

  An enumeration is a data type whose values are enumerated in the model as enumeration literals.

• Execution Environment (Execution Environment)

  An execution environment is a node that offers an execution environment for specific types of components that are deployed on it in the form of executable artifacts.

• Interaction (Interaction)

  An interaction is a unit of behavior that focuses on the observable exchange of information between connectable elements.

• Interface (Interface)

  An interface is a kind of classifier that represents a declaration of a set of coherent public features and obligations.

  An interface specifies a contract; any instance of a classifier that realizes the interface must fulfill that contract.

  The obligations that may be associated with an interface are in the form of various kinds of constraints (such as pre- and post-conditions) or protocol specifications, which may impose ordering restrictions on interactions through the interface.

  Interfaces may include receptions (in addition to operations). Since an interface specifies conformance characteristics, it does not own detailed behavior specifications. Instead, interfaces may own a protocol state machine that specifies event sequences and pre/post conditions for the operations and receptions described by the interface.

• Node (Node)

  A node is computational resource upon which artifacts may be deployed for execution. Nodes can be interconnected through communication paths to define network structures.

• Opaque Behavior (Opaque Behavior)

  An behavior with implementation-specific semantics.

• Primitive Type (Primitive Type)

  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.

• Protocol (Protocol)

  Only available together with the Real-Time Extension of RSA.

• Protocol State Machine (Protocol State Machine)

  A protocol state machine is always defined in the context of a classifier. It specifies which operations of the classifier can be called in which state and under which condition, thus specifying the allowed call sequences on the classifier's operations.

  A protocol state machine presents the possible and permitted transitions on the instances of its context classifier, together with the operations which carry the transitions. In this manner, an instance lifecycle can be created for a classifier, by specifying the order in which the operations can be activated and the states through which an instance progresses during its existence.

• Signal (Signal)

  A signal is a specification of send request instances communicated between objects. The receiving object handles the received request instances as specified by its receptions. The data carried by a send request (which was passed to it by the send invocation occurrence that caused that request) are represented as attributes of the signal.

  A signal is defined independently of the classifiers handling the signal occurrence.

• State Machine (State Machine)

  State machines can be used to express the behavior of part of a system.

  Behavior is modeled as a traversal of a graph of state nodes interconnected by one or more joined transition arcs that are triggered by the dispatching of series of (event) occurrences. During this traversal, the state machine executes a series of activities associated with various elements of the state machine.

• Stereotype (Stereotype)

  A stereotype defines how an existing metaclass may be extended, and enables the use of platform or domain specific terminology or notation in place of, or in addition to, the ones used for the extended metaclass.

• Template Parameter (Template Parameter)

  A template parameter exposes a parameterable element as a formal template parameter of a template.

Rules

• Arbitrary number of elements of the following kinds:
  • Attribute (Attribute)

    A property is a structural feature of a classifier that characterizes instances of the classifier.

    A property may represents an attribute and might also represent an association end. It relates an instance of the class to a value or set of values of the type of the attribute.

    A property related by memberEnd or its specializations to an association represents an end of the association. The type of the property is the type of the end of the association.

    An attribute is a property that has no reference to an association.

  • Template Signature (Template Signature)

    A template signature bundles the set of formal template parameters for a templated element.

Rules

• Arbitrary number of elements of the following kinds:
  • Abstraction (Abstraction)

    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.

  • Dependency (Dependency)

    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).

  • Information Flow (Information Flow)

    An information flow specifies that one or more information items circulates from its sources to its targets.

    Informationflows require some kind of information channel for transmitting information items from the source to the destination. An information channel is represented in various ways depending on the nature of its sources and targets. It may berepresented by connectors, links, associations, or even dependencies.

    For example, if the source and destination are partsin some composite structure such as a collaboration, then the information channel is likely to be represented by aconnector between them. Or, if the source and target are objects (which are a kind of instance specification), they may berepresented by a link that joins the two, and so on.

  • Realization (Realization)

    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.

  • Substitution (Substitution)

    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.

  • Templatebinding (Templatebinding)

    A template binding represents a relationship between a templateable element and a template. A template binding specifies the substitutions of actual parameters for the formal parameters of the template.

  • Usage (Usage)

    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.

• Can be the value of the Defining End property of Connector End (Connector End)
• Can be the value of the Defining Feature property of Slot (Slot)
• Can be the value of the Role property of Connector End (Connector End)
• Can be the Target of elements of the following kinds:
  • Abstraction (Abstraction)
  • Dependency (Dependency)
  • Deployment (Deployment)
  • Information Flow (Information Flow)
  • Realization (Realization)
  • Substitution (Substitution)
  • Usage (Usage)
• Can be the value of the Part With Port property of Connector End (Connector End)