This wiki: The development wiki is a work area where Jazz development teams plan and discuss technical designs and operations for the projects at Jazz.net. Work items often link to documents here. You are welcome to browse, follow along, and participate. Participation is what Jazz.net is all about! But please keep in mind that information here is "as is", unsupported, and may be outdated or inaccurate. For information on released products, consult IBM Knowledge Center, support tech notes, and the Jazz.net library. See also the Jazz.net Terms of Use. Any documentation or reference material found in this wiki is not official product documentation, but it is primarily for the use of the development teams. For your end use, you should consult official product documentation (infocenters), IBM.com support artifacts (tech notes), and the jazz.net library as officially "stamped" resources.

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

Activity is an RDF class.

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

See Also:

Actor

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

Actor is an RDF class.

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

See Also:

addition

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

addition is an RDF property.

References the use case that is to be included.

See Also:

aggregation

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

aggregation is an RDF property.

Specifies the kind of aggregation that applies to the Property.

See Also:

AggregationKind

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

AggregationKind is an RDF class.

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

See Also:

Artifact

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

Artifact is an RDF class.

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.

See Also:

Association

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

Association is an RDF class.

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

See Also:

AssociationClass

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

AssociationClass is an RDF class.

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

See Also:

Class

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

Class is an RDF 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.

See Also:

Collaboration

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

Collaboration is an RDF class.

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.

See Also:

collaborationRole

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

collaborationRole is an RDF property.

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

See Also:

CommunicationPath

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

CommunicationPath is an RDF class.

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

See Also:

Component

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

Component is an RDF class.

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.

See Also:

composite

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

composite is an RDF individual.

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

See Also:

contract

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

contract is an RDF property.

References the Interface specifying the conformance contract.

See Also:

contract

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

contract is an RDF property.

The contract with which the substituting classifier complies.

See Also:

DataType

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

DataType is an RDF class.

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.

See Also:

deployedArtifact

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

deployedArtifact is an RDF property.

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

See Also:

DeploymentSpecification

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

DeploymentSpecification is an RDF class.

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.

See Also:

Device

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

Device is an RDF class.

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

See Also:

Enumeration

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

Enumeration is an RDF class.

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

See Also:

ExecutionEnvironment

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

ExecutionEnvironment is an RDF class.

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.

See Also:

extendedCase

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

extendedCase is an RDF property.

References the use case that is being extended.

See Also:

general

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

general is an RDF property.

References the general classifier in the Generalization relationship.

See Also:

importedElement

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

importedElement is an RDF property.

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

See Also:

importedPackage

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

importedPackage is an RDF property.

Specifies the Package whose members are imported into a Namespace.

See Also:

Interaction

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

Interaction is an RDF class.

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

See Also:

Interface

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

Interface is an RDF class.

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.

See Also:

mergedPackage

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

mergedPackage is an RDF property.

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

See Also:

Model

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

Model is an RDF class.

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.

See Also:

nestedArtifact

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

nestedArtifact is an RDF property.

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

See Also:

nestedClassifier

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

nestedClassifier is an RDF property.

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

See Also:

nestedClassifier

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

nestedClassifier is an RDF property.

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

See Also:

nestedNode

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

nestedNode is an RDF property.

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

See Also:

Node

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

Node is an RDF class.

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

See Also:

none

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

none is an RDF individual.

Indicates that the property has no aggregation.

See Also:

OpaqueBehavior

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

OpaqueBehavior is an RDF class.

An behavior with implementation-specific semantics.

See Also:

Operation

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

Operation is an RDF class.

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.

See Also:

ownedActual

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

ownedActual is an RDF property.

The actual parameter that is owned by this substitution.

See Also:

ownedAttribute

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

ownedAttribute is an RDF property.

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

See Also:

ownedAttribute

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

ownedAttribute is an RDF property.

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

See Also:

ownedAttribute

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

ownedAttribute is an RDF property.

References the properties owned by the classifier.

See Also:

ownedAttribute

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

ownedAttribute is an RDF property.

The Attributes owned by the DataType.

See Also:

ownedAttribute

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

ownedAttribute is an RDF property.

The attributes owned by the signal.

See Also:

ownedBehavior

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

ownedBehavior is an RDF property.

References behavior specifications owned by a classifier.

See Also:

ownedEnd

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

ownedEnd is an RDF property.

The ends that are owned by the association itself.

See Also:

ownedOperation

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

ownedOperation is an RDF property.

The operations owned by the class.

See Also:

ownedOperation

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

ownedOperation is an RDF property.

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

See Also:

ownedOperation

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

ownedOperation is an RDF property.

The Operations owned by the DataType.

See Also:

ownedOperation

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

ownedOperation is an RDF property.

The operations owned by the class.

See Also:

ownedUseCase

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

ownedUseCase is an RDF property.

References the use cases owned by this classifier.

See Also:

Package

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

Package is an RDF class.

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.

See Also:

package

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

package is an RDF individual.

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.

See Also:

packagedElement

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

packagedElement is an RDF property.

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.

See Also:

packagedElement

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

packagedElement is an RDF property.

Specifies the packageable elements that are owned by this Package.

See Also:

Port

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

Port is an RDF class.

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.

See Also:

PrimitiveType

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

PrimitiveType is an RDF class.

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.

See Also:

private

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

private is an RDF individual.

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

See Also:

Property

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

Property is an RDF class.

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.

See Also:

protected

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

protected is an RDF individual.

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

See Also:

protocol

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

protocol is an RDF property.

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

See Also:

ProtocolStateMachine

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

ProtocolStateMachine is an RDF class.

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.

See Also:

public

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

public is an RDF individual.

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

See Also:

raisedException

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

raisedException is an RDF property.

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

See Also:

realizingClassifier

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

realizingClassifier is an RDF property.

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

See Also:

redefinedElement

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

redefinedElement is an RDF property.

The redefinable element that is being redefined by this element.

See Also:

shared

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

shared is an RDF individual.

Indicates that the property has a shared aggregation.

See Also:

Signal

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

Signal is an RDF class.

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.

See Also:

StateMachine

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

StateMachine is an RDF class.

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.

See Also:

UseCase

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

UseCase is an RDF class.

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.

See Also:

utilizedElement

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

utilizedElement is an RDF property.

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

See Also:

visibility

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

visibility is an RDF property.

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

See Also:

VisibilityKind

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

VisibilityKind is an RDF class.

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

See Also: