UML

Licensed Materials (See https://jazz.net/ns/license.html) - Property of IBM.
© Copyright IBM Corporation 2012. All Rights Reserved.
U.S. Government Users Restricted Rights: Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

The namespace URI for this vocabulary is:

http://jazz.net/ns/dm/rsa/uml#

This page lists the RDF classes, properties, and individuals that make up the vocabulary. Following W3C best practices, this information is available as HTML (this page) and as RDF.

More details on how this page was generated and other related material can be found in the wiki article Publishing RDF Vocabularies on jazz.net.

Description:

A vocabulary that defines concepts used in UML (Unified Modeling Language) specification.

See Also:

• http://en.wikipedia.org/wiki/Unified_Modeling_Language
• http://www.omg.org/spec/UML/2.4.1/
• https://jazz.net/help-dev/dm/index.jsp

Classes in this vocabulary:

Activity, Actor, AggregationKind, Artifact, Association, AssociationClass, Class, Collaboration, CommunicationPath, Component, DataType, DeploymentSpecification, Device, Enumeration, ExecutionEnvironment, Interaction, Interface, Model, Node, OpaqueBehavior, Operation, Package, Port, PrimitiveType, Property, ProtocolStateMachine, Signal, StateMachine, UseCase, VisibilityKind

Properties in this vocabulary:

addition, aggregation, collaborationRole, contract, contract, deployedArtifact, extendedCase, general, importedElement, importedPackage, mergedPackage, nestedArtifact, nestedClassifier, nestedClassifier, nestedNode, ownedActual, ownedAttribute, ownedAttribute, ownedAttribute, ownedAttribute, ownedAttribute, ownedBehavior, ownedEnd, ownedOperation, ownedOperation, ownedOperation, ownedOperation, ownedUseCase, packagedElement, packagedElement, protocol, raisedException, realizingClassifier, redefinedElement, utilizedElement, visibility

Activity

http://jazz.net/ns/dm/rsa/uml#Activity

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

Actor

http://jazz.net/ns/dm/rsa/uml#Actor

An actor specifies a role played by a user or any other system that interacts with the subject.

addition

http://jazz.net/ns/dm/rsa/uml#addition-Include

References the use case that is to be included.

aggregation

http://jazz.net/ns/dm/rsa/uml#aggregation-Property

Specifies the kind of aggregation that applies to the Property.

AggregationKind

http://jazz.net/ns/dm/rsa/uml#AggregationKind

AggregationKind is an enumeration type that specifies the literals for defining the kind of aggregation of a property.

Artifact

http://jazz.net/ns/dm/rsa/uml#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.

Association

http://jazz.net/ns/dm/rsa/uml#Association

An association describes a set of tuples whose values refer to typed instances. An instance of an association is called a link.

AssociationClass

http://jazz.net/ns/dm/rsa/uml#AssociationClass

An association describes a set of tuples whose values refer to typed instances. An instance of an association is called a link.

Class

http://jazz.net/ns/dm/rsa/uml#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

http://jazz.net/ns/dm/rsa/uml#Collaboration

A collaboration use represents the application of the pattern described by a collaboration to a specific situation involving specific classes or instances playing the roles of the collaboration.

collaborationRole

http://jazz.net/ns/dm/rsa/uml#collaborationRole-Collaboration

References connectable elements (possibly owned by other classifiers) which represent roles that instances may play in this collaboration.

CommunicationPath

http://jazz.net/ns/dm/rsa/uml#CommunicationPath

A communication path is an association between two deployment targets, through which they are able to exchange signals and messages.

Component

http://jazz.net/ns/dm/rsa/uml#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.

composite

http://jazz.net/ns/dm/rsa/uml#AggregationKind-composite

Indicates that the property is aggregated compositely, i.e., the composite object has responsibility for the existence and storage of the composed objects (parts).

contract

http://jazz.net/ns/dm/rsa/uml#contract-InterfaceRealization

References the Interface specifying the conformance contract.

contract

http://jazz.net/ns/dm/rsa/uml#contract-Substitution

The contract with which the substituting classifier complies.

DataType

http://jazz.net/ns/dm/rsa/uml#DataType

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.

deployedArtifact

http://jazz.net/ns/dm/rsa/uml#deployedArtifact-Deployment

The Artifacts that are deployed onto a Node. This association specializes the supplier association.

DeploymentSpecification

http://jazz.net/ns/dm/rsa/uml#DeploymentSpecification

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

http://jazz.net/ns/dm/rsa/uml#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

http://jazz.net/ns/dm/rsa/uml#Enumeration

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

ExecutionEnvironment

http://jazz.net/ns/dm/rsa/uml#ExecutionEnvironment

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.

extendedCase

http://jazz.net/ns/dm/rsa/uml#extendedCase-Extend

References the use case that is being extended.

general

http://jazz.net/ns/dm/rsa/uml#general-Generalization

References the general classifier in the Generalization relationship.

importedElement

http://jazz.net/ns/dm/rsa/uml#importedElement-ElementImport

Specifies the PackageableElement whose name is to be added to a Namespace.

importedPackage

http://jazz.net/ns/dm/rsa/uml#importedPackage-PackageImport

Specifies the Package whose members are imported into a Namespace.

Interaction

http://jazz.net/ns/dm/rsa/uml#Interaction

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

Interface

http://jazz.net/ns/dm/rsa/uml#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.

mergedPackage

http://jazz.net/ns/dm/rsa/uml#mergedPackage-PackageMerge

References the Package that is to be merged with the receiving package of the PackageMerge.

Model

http://jazz.net/ns/dm/rsa/uml#Model

A model captures a view of a physical system. It is an abstraction of the physical system, with a certain purpose. This purpose determines what is to be included in the model and what is irrelevant. Thus the model completely describes those aspects of the physical system that are relevant to the purpose of the model, at the appropriate level of detail.

nestedArtifact

http://jazz.net/ns/dm/rsa/uml#nestedArtifact-Artifact

The Artifacts that are defined (nested) within the Artifact. The association is a specialization of the ownedMember association from Namespace to NamedElement.

nestedClassifier

http://jazz.net/ns/dm/rsa/uml#nestedClassifier-Interface

References all the Classifiers that are defined (nested) within the Class.

nestedClassifier

http://jazz.net/ns/dm/rsa/uml#nestedClassifier-Class

References all the Classifiers that are defined (nested) within the Class.

nestedNode

http://jazz.net/ns/dm/rsa/uml#nestedNode-Node

The Nodes that are defined (nested) within the Node.

Node

http://jazz.net/ns/dm/rsa/uml#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.

none

http://jazz.net/ns/dm/rsa/uml#AggregationKind-none

Indicates that the property has no aggregation.

OpaqueBehavior

http://jazz.net/ns/dm/rsa/uml#OpaqueBehavior

An behavior with implementation-specific semantics.

Operation

http://jazz.net/ns/dm/rsa/uml#Operation

An operation is a behavioral feature of a classifier that specifies the name, type, parameters, and constraints for invoking an associated behavior. An operation may invoke both the execution of method behaviors as well as other behavioral responses. Operation specializes TemplateableElement in order to support specification of template operations and bound operations. Operation specializes ParameterableElement to specify that an operation can be exposed as a formal template parameter, and provided as an actual parameter in a binding of a template.

ownedActual

http://jazz.net/ns/dm/rsa/uml#ownedActual-TemplateParameterSubstitution

The actual parameter that is owned by this substitution.

ownedAttribute

http://jazz.net/ns/dm/rsa/uml#ownedAttribute-Interface

The attributes (i.e. the properties) owned by the class.

ownedAttribute

http://jazz.net/ns/dm/rsa/uml#ownedAttribute-Artifact

The attributes or association ends defined for the Artifact. The association is a specialization of the ownedMember association.

ownedAttribute

http://jazz.net/ns/dm/rsa/uml#ownedAttribute-StructuredClassifier

References the properties owned by the classifier.

ownedAttribute

http://jazz.net/ns/dm/rsa/uml#ownedAttribute-DataType

The Attributes owned by the DataType.

ownedAttribute

http://jazz.net/ns/dm/rsa/uml#ownedAttribute-Signal

The attributes owned by the signal.

ownedBehavior

http://jazz.net/ns/dm/rsa/uml#ownedBehavior-BehavioredClassifier

References behavior specifications owned by a classifier.

ownedEnd

http://jazz.net/ns/dm/rsa/uml#ownedEnd-Association

The ends that are owned by the association itself.

ownedOperation

http://jazz.net/ns/dm/rsa/uml#ownedOperation-Class

The operations owned by the class.

ownedOperation

http://jazz.net/ns/dm/rsa/uml#ownedOperation-Artifact

The Operations defined for the Artifact. The association is a specialization of the ownedMember association.

ownedOperation

http://jazz.net/ns/dm/rsa/uml#ownedOperation-DataType

The Operations owned by the DataType.

ownedOperation

http://jazz.net/ns/dm/rsa/uml#ownedOperation-Interface

The operations owned by the class.

ownedUseCase

http://jazz.net/ns/dm/rsa/uml#ownedUseCase-Classifier

References the use cases owned by this classifier.

Package

http://jazz.net/ns/dm/rsa/uml#Package

A package is used to group elements, and provides a namespace for the grouped elements. A package can have one or more profile applications to indicate which profiles have been applied. Because a profile is a package, it is possible to apply a profile not only to packages, but also to profiles. Package specializes TemplateableElement and PackageableElement specializes ParameterableElement to specify that a package can be used as a template and a PackageableElement as a template parameter.

package

http://jazz.net/ns/dm/rsa/uml#VisibilityKind-package

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.

packagedElement

http://jazz.net/ns/dm/rsa/uml#packagedElement-Component

The set of PackageableElements that a Component owns. In the namespace of a component, all model elements that are involved in or related to its definition may be owned or imported explicitly. These may include e.g. Classes, Interfaces, Components, Packages, Use cases, Dependencies (e.g. mappings), and Artifacts.

packagedElement

http://jazz.net/ns/dm/rsa/uml#packagedElement-Package

Specifies the packageable elements that are owned by this Package.

Port

http://jazz.net/ns/dm/rsa/uml#Port

A port is a property of a classifier that specifies a distinct interaction point between that classifier and its environment or between the (behavior of the) classifier and its internal parts. Ports are connected to properties of the classifier by connectors through which requests can be made to invoke the behavioral features of a classifier. A Port may specify the services a classifier provides (offers) to its environment as well as the services that a classifier expects (requires) of its environment. A port has an associated protocol state machine.

PrimitiveType

http://jazz.net/ns/dm/rsa/uml#PrimitiveType

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.

private

http://jazz.net/ns/dm/rsa/uml#VisibilityKind-private

A private element is only visible inside the namespace that owns it.

Property

http://jazz.net/ns/dm/rsa/uml#Property

A property is a structural feature of a classifier that characterizes instances of the classifier. A property related by ownedAttribute to a classifier (other than an association) 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. A property represents a set of instances that are owned by a containing classifier instance. A property has the capability of being a deployment target in a deployment relationship. This enables modeling the deployment to hierarchical nodes that have properties functioning as internal parts. Property represents a declared state of one or more instances in terms of a named relationship to a value or values. When a property is an attribute of a classifier, the value or values are related to the instance of the classifier by being held in slots of the instance. When a property is an association end, the value or values are related to the instance or instances at the other end(s) of the association. The range of valid values represented by the property can be controlled by setting the property's type. Property specializes ParameterableElement to specify that a property can be exposed as a formal template parameter, and provided as an actual parameter in a binding of a template.

protected

http://jazz.net/ns/dm/rsa/uml#VisibilityKind-protected

A protected element is visible to elements that have a generalization relationship to the namespace that owns it.

protocol

http://jazz.net/ns/dm/rsa/uml#protocol-Interface

References a protocol state machine specifying the legal sequences of the invocation of the behavioral features described in the interface.

ProtocolStateMachine

http://jazz.net/ns/dm/rsa/uml#ProtocolStateMachine

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.

public

http://jazz.net/ns/dm/rsa/uml#VisibilityKind-public

A public element is visible to all elements that can access the contents of the namespace that owns it.

raisedException

http://jazz.net/ns/dm/rsa/uml#raisedException-BehavioralFeature

References the Types representing exceptions that may be raised during an invocation of this feature. The signals that the behavioral feature raises as exceptions.

realizingClassifier

http://jazz.net/ns/dm/rsa/uml#realizingClassifier-ComponentRealization

The classifiers that are involved in the implementation of the Component that owns this Realization.

redefinedElement

http://jazz.net/ns/dm/rsa/uml#redefinedElement-RedefinableElement

The redefinable element that is being redefined by this element.

shared

http://jazz.net/ns/dm/rsa/uml#AggregationKind-shared

Indicates that the property has a shared aggregation.

Signal

http://jazz.net/ns/dm/rsa/uml#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.

StateMachine

http://jazz.net/ns/dm/rsa/uml#StateMachine

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.

UseCase

http://jazz.net/ns/dm/rsa/uml#UseCase

A use case is the specification of a set of actions performed by a system, which yields an observable result that is, typically, of value for one or more actors or other stakeholders of the system.

utilizedElement

http://jazz.net/ns/dm/rsa/uml#utilizedElement-Manifestation

The model element that is utilized in the manifestation in an Artifact.

visibility

http://jazz.net/ns/dm/rsa/uml#visibility-NamedElement

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

VisibilityKind

http://jazz.net/ns/dm/rsa/uml#VisibilityKind

VisibilityKind is an enumeration type that defines literals to determine the visibility of elements in a model.