|
Interface Summary |
| Abstraction |
An abstraction is a Dependency relationship that relates two
elements or sets of elements that represent the same concept at
different levels of abstraction or from different viewpoints. |
| AbstractionClass |
Class proxy for type Abstraction. |
| Artifact |
An Artifact represents a physical piece of information that is used
or produced by a software development process. |
| ArtifactClass |
Class proxy for type Artifact. |
| Association |
An association defines a semantic relationship between classifiers. |
| AssociationClass |
Class proxy for type Association. |
| AssociationEnd |
An association end is an endpoint of an association, which connects
the association to a classifier. |
| AssociationEndClass |
Class proxy for type AssociationEnd. |
| AssociationUMLClass |
An association class is an association that is also a class. |
| AssociationUMLClassClass |
Class proxy for type AssociationUMLClass. |
| Attribute |
An attribute is a named slot within a classifier that describes a
range of values that instances of the classifier may hold. |
| AttributeClass |
Class proxy for type Attribute. |
| BehavioralFeature |
A behavioral feature refers to a dynamic feature of a model element,
such as an operation or method. |
| BehavioralFeatureClass |
Class proxy for type BehavioralFeature. |
| Binding |
A binding is a relationship between a template (as supplier) and a
model element generated from the template (as client). |
| BindingClass |
Class proxy for type Binding. |
| Classifier |
A classifier is an element that describes behavioral and structural
features; it comes in several specific forms, including class,
data type, interface, component, artifact, and others that are
defined in other metamodel packages. |
| ClassifierClass |
Class proxy for type Classifier. |
| Comment |
A comment is an annotation attached to a model element or a set of
model elements. |
| CommentClass |
Class proxy for type Comment. |
| Component |
A component represents a modular, deployable, and replaceable part
of a system that encapsulates implementation and exposes a set of
interfaces. |
| ComponentClass |
Class proxy for type Component. |
| Constraint |
A constraint is a semantic condition or restriction expressed in
text. |
| ConstraintClass |
Class proxy for type Constraint. |
| CorePackage |
|
| DataType |
A data type is a type whose values have no identity (i.e., they are
pure values). |
| DataTypeClass |
Class proxy for type DataType. |
| Dependency |
A term of convenience for a Relationship other than Association,
Generalization, Flow, or metarelationship (such as the relationship
between a Classifier and one of its Instances). |
| DependencyClass |
Class proxy for type Dependency. |
| Element |
An element is an atomic constituent of a model. |
| ElementClass |
Class proxy for type Element. |
| Enumeration |
In the metamodel, Enumeration defines a kind of DataType whose range
is a list of predefined values, called enumeration literals. |
| EnumerationClass |
Class proxy for type Enumeration. |
| EnumerationLiteral |
An EnumerationLiteral defines an element of the run-time extension
of an Enumeration data type. |
| EnumerationLiteralClass |
Class proxy for type EnumerationLiteral. |
| Feature |
A feature is a property, like operation or attribute, which is
encapsulated within a Classifier. |
| FeatureClass |
Class proxy for type Feature. |
| Flow |
A flow is a relationship between two versions of an object or
between an object and a copy of it. |
| FlowClass |
Class proxy for type Flow. |
| GeneralizableElement |
A generalizable element is a model element that may participate in
a generalization relationship. |
| GeneralizableElementClass |
Class proxy for type GeneralizableElement. |
| Generalization |
A generalization is a taxonomic relationship between a more general
element and a more specific element. |
| GeneralizationClass |
Class proxy for type Generalization. |
| Method |
A method is the implementation of an operation. |
| MethodClass |
Class proxy for type Method. |
| ModelElement |
A model element is an element that is an abstraction drawn from the
system being modeled. |
| ModelElementClass |
Class proxy for type ModelElement. |
| Namespace |
A namespace is a part of a model that contains a set of
ModelElements each of whose names designates a unique element within
the namespace. |
| NamespaceClass |
Class proxy for type Namespace. |
| Node |
A node is a run-time physical object that represents a computational
resource, generally having at least a memory and often processing
capability as well, and upon which components may be deployed. |
| NodeClass |
Class proxy for type Node. |
| Operation |
An operation is a service that can be requested from an object to
effect behavior. |
| OperationClass |
Class proxy for type Operation. |
| Parameter |
A parameter is an unbound variable that can be changed, passed, or
returned. |
| ParameterClass |
Class proxy for type Parameter. |
| Permission |
Permission is a kind of dependency. |
| PermissionClass |
Class proxy for type Permission. |
| PresentationElement |
A presentation element is a textual or graphical presentation of
one or more model elements. |
| PresentationElementClass |
Class proxy for type PresentationElement. |
| Primitive |
A Primitive defines a predefined DataType, without any relevant UML
substructure (i.e., it has no UML parts). |
| PrimitiveClass |
Class proxy for type Primitive. |
| ProgrammingLanguageDataType |
A data type is a type whose values have no identity (i.e., they are
pure values). |
| ProgrammingLanguageDataTypeClass |
Class proxy for type ProgrammingLanguageDataType. |
| Relationship |
A relationship is a connection among model elements. |
| RelationshipClass |
Class proxy for type Relationship. |
| StructuralFeature |
A structural feature refers to a static feature of a model element,
such as an attribute. |
| StructuralFeatureClass |
Class proxy for type StructuralFeature. |
| TemplateArgument |
Reifies the relationship between a Binding and one of its arguments
(a ModelElement). |
| TemplateArgumentClass |
Class proxy for type TemplateArgument. |
| UMLClass |
A class is a description of a set of objects that share the same
attributes, operations, methods, relationships, and semantics. |
| UMLClassClass |
Class proxy for type UMLClass. |
| UMLInterface |
An interface is a named set of operations that characterize the
behavior of an element. |
| UMLInterfaceClass |
Class proxy for type UMLInterface. |
| Usage |
A usage is a relationship in which one element requires another
element (or set of elements) for its full implementation or
operation. |
| UsageClass |
Class proxy for type Usage. |