r11 - 2014-02-22 - 17:42:02 - Main.rymanYou are here: TWiki >  LinkedData Web > RsaUmlVocabulary
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.

New product names: The CE/CLM products were renamed in version 7.0. For details on the name change, see Renaming the IBM Continuous Engineering Portfolio. Some content might continue to use the previous names or contain a combination of the previous and current names.

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:

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:
                                                                                                                                                    Topic attachments
                                                                                                                                                    I Attachment Action Size Date Who Comment
                                                                                                                                                    Htmlhtml RSA_UML.html manage 39.6 K 2012-07-20 - 23:12 UnknownUser RsaUml vocabulary in HTML format
                                                                                                                                                    Rdfrdf RSA_UML.rdf manage 46.3 K 2012-07-20 - 22:31 UnknownUser RsaUml vocabulary in RDF/XML format
                                                                                                                                                    Ttlttl RSA_UML.ttl manage 29.5 K 2012-07-20 - 22:31 UnknownUser RsaUml vocabulary in Turtle format
                                                                                                                                                    Edit | WYSIWYG | Attach | Printable | Raw View | Backlinks: Web, All Webs | History: r11 < r10 < r9 < r8 < r7 | More topic actions
                                                                                                                                                    LinkedData.RsaUmlVocabulary moved from Main.RsaUmlVocabulary on 2014-02-22 - 16:30 by Main.ryman -
                                                                                                                                                     
                                                                                                                                                    This site is powered by the TWiki collaboration platformCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
                                                                                                                                                    Contributions are governed by our Terms of Use
                                                                                                                                                    Ideas, requests, problems regarding TWiki? Send feedback