Namespace NMF.Interop.Legacy.Cmof

Classes

Argument: The default implementation of the Argument class

An association specifies a semantic relationship that can occur between typed instances. It has at least two ends represented by properties, each of which is connected to the type of the end. More than one end of an association may have the same type.

An end property of an association that is owned by an end class or that is a navigable owned end of the association indicates that the association is navigable from the opposite ends, otherwise the association is not navigable from the opposite ends.

Association.AssociationChildrenCollection: The collection class to to represent the children of the Association class

Association.AssociationReferencedElementsCollection: The collection class to to represent the children of the Association class

AssociationMemberEndCollection: Denotes a class to implement the memberEnd reference

AssociationOwnedEndCollection: Denotes a class to implement the ownedEnd reference

AssociationOwnedEndCollection0: The collection class to implement the refined ownedEnd reference for the Association class

BehavioralFeature: A behavioral feature is a feature of a classifier that specifies an aspect of the behavior of its instances. BehavioralFeature is an abstract metaclass specializing Feature and Namespace. Kinds of behavioral aspects are modeled by subclasses of BehavioralFeature.

BehavioralFeature.BehavioralFeatureChildrenCollection: The collection class to to represent the children of the BehavioralFeature class

BehavioralFeature.BehavioralFeatureReferencedElementsCollection: The collection class to to represent the children of the BehavioralFeature class

Class: Class is a kind of classifier whose features are attributes and operations. Attributes of a class are represented by instances of Property that are owned by the class. Some of these attributes may represent the navigable ends of binary associations. A class is a type that has objects as its instances.

Class.ClassChildrenCollection: The collection class to to represent the children of the Class class

Class.ClassReferencedElementsCollection: The collection class to to represent the children of the Class class

ClassOwnedAttributeCollection: Denotes a class to implement the ownedAttribute reference

ClassOwnedOperationCollection: Denotes a class to implement the ownedOperation reference

Classifier: A classifier is a type. It can specify a generalization hierarchy by referencing its general classifiers. A classifier is also a namespace whose members can include features. Classifier is an abstract metaclass.

Classifier.ClassifierChildrenCollection: The collection class to to represent the children of the Classifier class

Classifier.ClassifierReferencedElementsCollection: The collection class to to represent the children of the Classifier class

Comment: A comment is a textual annotation that can be attached to a set of elements. A comment gives the ability to attach various remarks to elements. A comment carries no semantic force, but may contain information that is useful to a modeler. A comment may be owned by any element.

Comment.CommentReferencedElementsCollection: The collection class to to represent the children of the Comment class

Constraint

Constraint contains a ValueSpecification that specifies additional semantics for one or more elements. Certain kinds of constraints (such as an association "xor" constraint) are predefined in UML, others may be user-defined. A user-defined Constraint is described using a specified language, whose syntax and interpretation is a tool responsibility. One predefined language for writing constraints is OCL. In some situations, a programming language such as Java may be appropriate for expressing a constraint. In other situations natural language may be used.

Constraint is a condition (a Boolean expression) that restricts the extension of the associated element beyond what is imposed by the other language constructs applied to the element. Constraint contains an optional name, although they are commonly unnamed.

Constraint.ConstraintChildrenCollection: The collection class to to represent the children of the Constraint class

Constraint.ConstraintReferencedElementsCollection: The collection class to to represent the children of the Constraint class

DataType

A data type is a type whose instances are identified only by their value. A DataType may contain attributes to support the modeling of structured data types.

A typical use of data types would be to represent programming language primitive types or CORBA basic types. For example, integer and string types are often treated as data types. DataType is an abstract class that acts as a common superclass for different kinds of data types.

DataType.DataTypeChildrenCollection: The collection class to to represent the children of the DataType class

DataType.DataTypeReferencedElementsCollection: The collection class to to represent the children of the DataType class

DataTypeOwnedAttributeCollection: Denotes a class to implement the ownedAttribute reference

DataTypeOwnedOperationCollection: Denotes a class to implement the ownedOperation reference

DirectedRelationship: A directed relationship references one or more source elements and one or more target elements. DirectedRelationship is an abstract metaclass.

Element: An element can own comments. Element is an abstract metaclass with no superclass. It is used as the common superclass for all metaclasses in the infrastructure library.

Element.ElementChildrenCollection: The collection class to to represent the children of the Element class

Element.ElementReferencedElementsCollection: The collection class to to represent the children of the Element class

ElementImport: An element import is defined as a directed relationship between an importing namespace and a packageable element. The name of the packageable element or its alias is to be added to the namespace of the importing namespace. It is also possible to control whether the imported element can be further imported.

ElementImport.ElementImportReferencedElementsCollection: The collection class to to represent the children of the ElementImport class

Enumeration

Enumeration is a kind of data type, whose instances may be any of a number of predefined enumeration literals.

It is possible to extend the set of applicable enumeration literals in other packages or profiles.

An enumeration defines a set of literals that can be used as its values.

Enumeration.EnumerationChildrenCollection: The collection class to to represent the children of the Enumeration class

Enumeration.EnumerationReferencedElementsCollection: The collection class to to represent the children of the Enumeration class

EnumerationLiteral: An enumeration literal is a value of an enumeration.

EnumerationLiteral.EnumerationLiteralReferencedElementsCollection: The collection class to to represent the children of the EnumerationLiteral class

EnumerationOwnedLiteralCollection: Denotes a class to implement the ownedLiteral reference

Exception: The default implementation of the Exception class

Exception.ExceptionReferencedElementsCollection: The collection class to to represent the children of the Exception class

Expression: An expression is a structured tree of symbols that denotes a (possibly empty) set of values when evaluated in a context.

Expression.ExpressionChildrenCollection: The collection class to to represent the children of the Expression class

Expression.ExpressionReferencedElementsCollection: The collection class to to represent the children of the Expression class

Factory: The default implementation of the Factory class

Factory.FactoryReferencedElementsCollection: The collection class to to represent the children of the Factory class

Feature: A feature declares a behavioral or structural characteristic of instances of classifiers. Feature is an abstract metaclass.

Link: The default implementation of the Link class

Link.LinkReferencedElementsCollection: The collection class to to represent the children of the Link class

MultiplicityElement: A MultiplicityElement is an abstract metaclass which includes optional attributes for defining the bounds of a multiplicity. A MultiplicityElement also includes specifications of whether the values in an instantiation of this element must be unique or ordered.

NamedElement: NamedElement has a visibility attribute. A named element represents elements with names.

Namespace: A namespace has the ability to import either individial members or all members of a package, thereby making it possible to refer to those named elements without qualification in the importing namespace. In the case of conflicts, it is necessary to use qualified names or aliases to disambiguate the referenced elements.

Namespace.NamespaceChildrenCollection: The collection class to to represent the children of the Namespace class

Namespace.NamespaceReferencedElementsCollection: The collection class to to represent the children of the Namespace class

NamespaceElementImportCollection: Denotes a class to implement the elementImport reference

NamespaceOwnedRuleCollection: Denotes a class to implement the ownedRule reference

NamespacePackageImportCollection: Denotes a class to implement the packageImport reference

OpaqueExpression: An opaque expression contains language-specific text strings used to describe a value or values, and an optional specification of the languages.

Operation: An operation is owned by a class and may be invoked in the context of objects that are instances of that class. It is a typed element and a multiplicity element.

Operation.OperationChildrenCollection: The collection class to to represent the children of the Operation class

Operation.OperationReferencedElementsCollection: The collection class to to represent the children of the Operation class

OperationOwnedRuleCollection: The collection class to implement the refined ownedRule reference for the Operation class

Package: A package is a namespace for its members, and may contain other packages. Only packageable elements can be owned members of a package. By virtue of being a namespace, a package can import either individual members of other packages, or all the members of other packages. In addition a package can be merged with other packages. A package is a container for types and other packages.

Package.PackageChildrenCollection: The collection class to to represent the children of the Package class

Package.PackageReferencedElementsCollection: The collection class to to represent the children of the Package class

PackageImport: A package import is defined as a directed relationship that identifies a package whose members are to be imported by a namespace.

PackageImport.PackageImportReferencedElementsCollection: The collection class to to represent the children of the PackageImport class

PackageMerge

A package merge is a directed relationship between two packages, that indicates that the contents of the two packages are to be combined. It is very similar to Generalization in the sense that the source element conceptually adds the characteristics of the target element to its own characteristics resulting in an element that combines the characteristics of both.

This mechanism should be used when elements defined in different packages have the same name and are intended to represent the same concept. Most often it is used to provide different definitions of a given concept for different purposes, starting from a common base definition. A given base concept is extended in increments, with each increment defined in a separate merged package. By selecting which increments to merge, it is possible to obtain a custom definition of a concept for a specific end. Package merge is particularly useful in meta-modeling and is extensively used in the definition of the UML metamodel.

Conceptually, a package merge can be viewed as an operation that takes the contents of two packages and produces a new package that combines the contents of the packages involved in the merge. In terms of model semantics, there is no difference between a model with explicit package merges, and a model in which all the merges have been performed.

PackageMerge.PackageMergeReferencedElementsCollection: The collection class to to represent the children of the PackageMerge class

PackageNestedPackageCollection: Denotes a class to implement the nestedPackage reference

PackageOwnedMemberCollection: The collection class to implement the refined ownedMember reference for the Package class

PackageOwnedTypeCollection: Denotes a class to implement the ownedType reference

PackagePackageMergeCollection: Denotes a class to implement the packageMerge reference

PackageableElement: A packageable element indicates a named element that may be owned directly by a package.

Parameter: A parameter is a kind of typed element in order to allow the specification of an optional multiplicity on parameters. In addition, it supports the specification of an optional default value. A parameter is a typed element that represents a parameter of an operation.

Parameter.ParameterChildrenCollection: The collection class to to represent the children of the Parameter class

Parameter.ParameterReferencedElementsCollection: The collection class to to represent the children of the Parameter class

ParameterDirectionKindConverter: Implements a type converter for the enumeration ParameterDirectionKind

PrimitiveType

The PrimitiveTypes subpackage within the Core package defines the different types of primitive values that are used to define the Core metamodel. It is also intended that every metamodel based on Core will reuse the following primitive types.

In Core and the UML metamodel, these primitive types are predefined and available to the Core and UML extensions at all time. These predefined value types are independent of any object model and part of the definition of the Core.

A primitive type is a data type implemented by the underlying infrastructure and made available for modeling.

Property

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.

Property is indirectly a subclass of Constructs::TypedElement. The range of valid values represented by the property can be controlled by setting the property's type. A property is a typed element that represents an attribute of a class.

Property.PropertyChildrenCollection: The collection class to to represent the children of the Property class

Property.PropertyReferencedElementsCollection: The collection class to to represent the children of the Property class

RedefinableElement: A redefinable element is an element that, when defined in the context of a classifier, can be redefined more specifically or differently in the context of another classifier that specializes (directly or indirectly) the context classifier.

Relationship: A relationship references one or more related elements. Relationship is an abstract metaclass.

StructuralFeature: A structural feature is a typed feature of a classifier that specifies the structure of instances of the classifier. Structural feature is an abstract metaclass.

StructuralFeature.StructuralFeatureChildrenCollection: The collection class to to represent the children of the StructuralFeature class

Tag: The default implementation of the Tag class

Tag.TagReferencedElementsCollection: The collection class to to represent the children of the Tag class

Type: A type serves as a constraint on the range of values represented by a typed element. Type is an abstract metaclass. A type is a named element that is used as the type for a typed element. A type can be contained in a package.

Type.TypeReferencedElementsCollection: The collection class to to represent the children of the Type class

TypedElement: A typed element is an element that has a type that serves as a constraint on the range of values the element can represent. Typed element is an abstract metaclass. A typed element is a kind of named element that represents elements with types.

TypedElement.TypedElementReferencedElementsCollection: The collection class to to represent the children of the TypedElement class

ValueSpecification: ValueSpecification is an abstract metaclass used to identify a value or values in a model. It may reference an instance or it may be an expression denoting an instance or instances when evaluated. It adds a specialization to Constructs::TypedElement.

ValueSpecification.ValueSpecificationChildrenCollection: The collection class to to represent the children of the ValueSpecification class

VisibilityKindConverter: Implements a type converter for the enumeration VisibilityKind

Interfaces

IArgument: The public interface for Argument

IAssociation: The public interface for Association

IBehavioralFeature: The public interface for BehavioralFeature

IClass: The public interface for Class

IClassifier: The public interface for Classifier

IComment: The public interface for Comment

IConstraint: The public interface for Constraint

IDataType: The public interface for DataType

IDirectedRelationship: The public interface for DirectedRelationship

IElement: The public interface for Element

IElementImport: The public interface for ElementImport

IEnumeration: The public interface for Enumeration

IEnumerationLiteral: The public interface for EnumerationLiteral

IException: The public interface for Exception

IExpression: The public interface for Expression

IFactory: The public interface for Factory

IFeature: The public interface for Feature

ILink: The public interface for Link

IMultiplicityElement: The public interface for MultiplicityElement

INamedElement: The public interface for NamedElement

INamespace: The public interface for Namespace

IOpaqueExpression: The public interface for OpaqueExpression

IOperation: The public interface for Operation

IPackage: The public interface for Package

IPackageImport: The public interface for PackageImport

IPackageMerge: The public interface for PackageMerge

IPackageableElement: The public interface for PackageableElement

IParameter: The public interface for Parameter

IPrimitiveType: The public interface for PrimitiveType

IProperty: The public interface for Property

IRedefinableElement: The public interface for RedefinableElement

IRelationship: The public interface for Relationship

IStructuralFeature: The public interface for StructuralFeature

ITag: The public interface for Tag

IType: The public interface for Type

ITypedElement: The public interface for TypedElement

IValueSpecification: The public interface for ValueSpecification

Enums

ParameterDirectionKind

ParameterDirectionKind is an enumeration of the following literal values:

in Indicates that parameter values are passed into the behavioral element by the caller.
inout Indicates that parameter values are passed into a behavioral element by the caller and then back out to the caller from the behavioral element.
out Indicates that parameter values are passed from a behavioral element out to the caller.
return Indicates that parameter values are passed as return values from a behavioral element back to the caller.

VisibilityKind

VisibilityKind is an enumeration of the following literal values:

public
private
protected
package

Table of Contents

Namespace NMF.Interop.Legacy.Cmof

Classes

Interfaces

Enums