Previous Table of Contents Next


7.5 MOF Model Associations

 7.5.1 Contains

   A meta-model is defined through a composition of ModelElements. A Namespace defines a ModelElement that composes other ModelElements. Since Namespace has several subclasses, there is a sizable combinatorial set of potential Namespace-ModelElement pairings. However, some of these pairings are not appropriate for building an object-oriented meta-model, such as a Class containing a Package (see 7.3.4, “The MOF Model Containment Hierarchy,? on page 40 ). This approach factors the container mechanisms into one abstraction, and allows the greatest flexibility for future changes to the MOF Model.

   Ends

   container containedElement

Each Namespace is a composition of zero or more ModelElements.

class:

multiplicity:

aggregation:

Namespace
zero or one
Namespace forms a composite aggregation of ModelElements.

Each ModelElement, with the exception of top-level packages participates in the association as a containedElement.

class:

multiplicity:

ModelElement
Zero or more; ordered.

   IDL

   interface Contains : Reflective::RefAssociation { ContainsLinkSet all_contains_links () raises (Reflective::MofError); boolean exists (in Namespace container, in ModelElement contained_element) raises (Reflective::MofError); Namespace container (in ModelElement contained_element) raises (Reflective::MofError); ModelElementUList contained_element (in Namespace container) raises (Reflective::MofError); void add (in Namespace container, in ModelElement contained_element) raises (Reflective::MofError);

   void add_before_contained_element (in Namespace container,in ModelElement contained_element,in ModelElement before)

    raises (Reflective::NotFound, Reflective::MofError);

   void modify_container (in Namespace container,in ModelElement contained_element,in Namespace new_container)

    raises (Reflective::NotFound, Reflective::MofError);

   void modify_contained_element (in Namespace container,in ModelElement contained_element,in ModelElement new_contained_element)

    raises (Reflective::NotFound, Reflective::MofError);void remove (in Namespace container, in ModelElement contained_element) raises (Reflective::NotFound, Reflective::MofError); };

7.5.2 Generalizes

   The Association defined on GeneralizableElement. A Link of this Association represents a supertype/subtype relationship (or a generalizes/specializes relationship).

   Ends

   supertype subtype

The GeneralizableElement that is more general is the supertype.

class:

multiplicity:

GeneralizabelElement
Zero or more (a GeneralizableElement may have zero or more supertypes); ordered.

The subtype is the GeneralizableElement that is more specific. The supertype Generalizes the subtype.

class:

multiplicity:

GeneralizableElement
Zero or more (a GeneralizableElement may have zero or more subtypes).

   IDL

   interface Generalizes : Reflective::RefAssociation {

   GeneralizesLinkSet all_generalizes_links ()

   raises (Reflective::MofError);

    boolean exists (in GeneralizableElement supertype,

    in GeneralizableElement subtype)

   raises (Reflective::MofError);

   GeneralizableElementUList supertype (in GeneralizableElement subtype)

   raises (Reflective::MofError);

   GeneralizableElementSet subtype (in GeneralizableElement supertype)

   raises (Reflective::MofError);

   void add (in GeneralizableElement supertype,

    in GeneralizableElement subtype)

   raises (Reflective::MofError);

   void add_before_supertype (in GeneralizableElement supertype,

    in GeneralizableElement subtype,

    in GeneralizableElement before)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_supertype (in GeneralizableElement supertype,

   in GeneralizableElement subtype,

   in GeneralizableElement new_supertype)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_subtype (in GeneralizableElement supertype,

   in GeneralizableElement subtype,

   in GeneralizableElement new_subtype)

   raises (Reflective::NotFound, Reflective::MofError);

   void remove (in GeneralizableElement supertype,

   in GeneralizableElement subtype)

   raises (Reflective::NotFound, Reflective::MofError);

    };

7.5.3 RefersTo

   A Reference derives most of its state from the AssociationEnd that it is linked to, based on this Association. For a Class defined with a Reference, each of its instances can be used to access the referenced object or objects. Those referenced objects will be of the Class defined by this referencedEnd AssociationEnd, playing the defined end.

   Ends referent

The Reference that is providing the reference through which instances playing the end-defined by the AssociationEnd can be accessed.

class:

multiplicity:

Reference
Zero or more; not ordered (an AssociationEnd may or may not be used by any number of References).

   referencedEnd

The AssociationEnd which provides the majority of information for the Reference, including the LinkEnds that supply the referenced instances.

class:

multiplicity:

AssociationEnd
exactly one

   IDL

   interface RefersTo : Reflective::RefAssociation {

   RefersToLinkSet all_refers_to_links ()

   raises (Reflective::MofError);

   boolean exists (in Reference referent, in AssociationEnd referenced_end)

    raises (Reflective::MofError);

   ReferenceSet referent (in AssociationEnd referenced_end)

    raises (Reflective::MofError);

   AssociationEnd referenced_end (in Reference referent)

    raises (Reflective::MofError);

   void add (in Reference referent, in AssociationEnd referenced_end)

    raises (Reflective::MofError);

   void modify_referent (in Reference referent,

   in AssociationEnd referenced_end,

   in Reference new_referent)

    raises (Reflective::NotFound, Reflective::MofError);

   void modify_referenced_end (in Reference referent,

   in AssociationEnd referenced_end,

   in AssociationEnd new_referenced_end)

    raises (Reflective::NotFound, Reflective::MofError);

   void remove (in Reference referent, in AssociationEnd referenced_end)

    raises (Reflective::NotFound, Reflective::MofError);

    };

7.5.4 Exposes (derived)

   A Reference defines a reference for a Class. For an instance of that class, which holds one or more links to some object or objects conforming to the reference, the instance will be playing the role (end) defined by the AssociationEnd in this Association.

    ISO/IEC 19502:2005(E)

   Ends referrer

The Reference that is providing the exposedEnd’s class instances within the Reference’s Classifier.

class:

multiplicity:

changeable:

Reference
Zero or more; not ordered (an AssociationEnd may or may not be used by any number of References).
yes

   exposedEnd

The AssociationEnd representing the Reference’s owning Classifier’s end in the Association.

class:

multiplicity:

changeable:

AssociationEnd
exactly one
yes

   Derivation

   See [S-13] on page 130 . For a given Reference, the Link of this Association is derived as follows:

   IDL

   interface Exposes : Reflective::RefAssociation { ExposesLinkSet all_exposes_links () raises (Reflective::MofError); boolean exists (in Reference referrer, in AssociationEnd exposed_end) raises (Reflective::MofError); ReferenceSet referrer (in AssociationEnd exposed_end) raises (Reflective::MofError); AssociationEnd exposed_end (in Reference referrer) raises (Reflective::MofError); void add (in Reference referrer, in AssociationEnd exposed_end) raises (Reflective::MofError);

   void modify_referrer (in Reference referrer,in AssociationEnd exposed_end,in Reference new_referrer)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_exposed_end (in Reference referrer,in AssociationEnd exposed_end,in AssociationEnd new_exposed_end)

   raises (Reflective::NotFound, Reflective::MofError);void remove (in Reference referrer, in AssociationEnd exposed_end)raises (Reflective::NotFound, Reflective::MofError); };

7.5.5 IsOfType

   A Link between a TypedElement subclass and a Classifier supports the definition of the TypedElement.

   Ends type

The type defining the TypedElement.

class: Classifier
multiplicity: exactly one

   typedElements

The set of typed elements supported by a Classifier.

class:

multiplicity:

TypedElement
zero or more

   IDL

   interface IsOfType : Reflective::RefAssociation { IsOfTypeLinkSet all_is_of_type_links () raises (Reflective::MofError); boolean exists (in Classifier type, in TypedElement typed_elements) raises (Reflective::MofError); Classifier type (in TypedElement typed_elements) raises (Reflective::MofError); TypedElementSet typed_elements (in Classifier type) raises (Reflective::MofError); void add (in Classifier type, in TypedElement typed_elements) raises (Reflective::MofError);

   void modify_type (in Classifier type,in TypedElement typed_elements,in Classifier new_type)

    raises (Reflective::NotFound, Reflective::MofError);

   void modify_typed_elements (in Classifier type,in TypedElement typed_elements,in TypedElement new_typed_elements)

    raises (Reflective::NotFound, Reflective::MofError); void remove (in Classifier type, in TypedElement typed_elements) raises (Reflective::NotFound, Reflective::MofError); };

7.5.6 CanRaise

   Relates Operations to the Exceptions that they can raise.

    ISO/IEC 19502:2005(E)

   Ends operation

Given an Exception, the set of Operations which can Raise that Exception.

class:

multiplicity:

Operation
Zero or more (an Exception may be defined that is not currently used by any Operation; an Exception may be raised by multiple Operations).

   except

The set of Exceptions for an Operation.

class:

multiplicity:

Exception
Zero or more (an Operation may be defined to raise no exception, or multiple exceptions); ordered (an Operation’s Exceptions are ordered).

   IDL

   interface CanRaise : Reflective::RefAssociation { CanRaiseLinkSet all_can_raise_links () raises (Reflective::MofError); boolean exists (in ::Model::Operation operation, in MofException except) raises (Reflective::MofError); OperationSet operation (in MofException except) raises (Reflective::MofError); MofExceptionUList except (in ::Model::Operation operation) raises (Reflective::MofError); void add (in ::Model::Operation operation, in MofException except) raises (Reflective::MofError);

   void add_before_except (in ::Model::Operation operation,in MofException except,in MofException before)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_operation (in Operation operation,in MofException except,in Operation new_operation)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_except (in ::Model::Operation operation,in MofException except,in MofException new_except)

   raises (Reflective::NotFound, Reflective::MofError); void remove (in ::Model::Operation operation, in MofException except) raises (Reflective::NotFound, Reflective::MofError); };

7.5.7 Aliases

   An Import aliases or imports a single Namespace.

   Ends importer

A Namespace may be aliased by an Import, which is the importer.

class:

multiplicity:

Import
Zero or more (a Namespace may not be aliased, or may be aliased by multiple Imports).

   imported

The Namespace that an Import imports or aliases.

class:

multiplicity:

Namespace
exactly one

   IDL

   interface Aliases : Reflective::RefAssociation { AliasesLinkSet all_aliases_links () raises (Reflective::MofError); boolean exists (in Import importer, in Namespace imported) raises (Reflective::MofError); ImportSet importer (in Namespace imported) raises (Reflective::MofError); Namespace imported (in Import importer) raises (Reflective::MofError); void add (in Import importer, in Namespace imported) raises (Reflective::MofError);

   void modify_importer (in Import importer, in Namespace imported, in Import new_importer)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_imported (in Import importer, in Namespace imported, in Namespace new_imported)

   raises (Reflective::NotFound, Reflective::MofError); void remove (in Import importer, in Namespace imported) raises (Reflective::NotFound, Reflective::MofError); };

7.5.8 Constrains

   Each Constraint constrains one or more ModelElements.

    ISO/IEC 19502:2005(E)

   Ends constraint

A Constraint that constrains a ModelElement.

class:

multiplicity:

Constraint
Zero or more (a ModelElement need not be constrained, but could be constrained by more than one Constraint).

   constrainedElement

The ModelElements that a Constraint holds its constraint against.

class:

multiplicity:

ModelElement
One or more (a Constraint must constrain at least one ModelElement).

   IDL

   interface Constrains : Reflective::RefAssociation {

   ConstrainsLinkSet all_constrains_links ()

   raises (Reflective::MofError);

   boolean exists (in ::Model::Constraint constraint,

   in ModelElement constrained_element)

   raises (Reflective::MofError);

   ConstraintSet constraint (in ModelElement constrained_element);

   raises (Reflective::MofError)

   ModelElementSet constrained_element (in ::Model::Constraint constraint)

   raises (Reflective::MofError);

   void add (in ::Model::Constraint constraint,

   in ModelElement constrained_element)

   raises (Reflective::MofError);

   void modify_constraint (in ::Model::Constraint constraint,

   in ModelElement constrained_element,

   in Constraint new_constraint)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_constrained_element (in ::Model::Constraint constraint,

   in ModelElement constrained_element,

   in ModelElement new_constrained_element)

   raises (Reflective::NotFound, Reflective::MofError); void remove (in ::Model::Constraint constraint, in ModelElement constrained_element) raises (Reflective::NotFound, Reflective::MofError); };

7.5.9 DependsOn (derived)

   DependsOn is a derived Association that allows a client to identify the collection of ModelElements on which a given ModelElement structurally depends. The Association is derived from a number of other Associations in the MOF Model, as described below.

   NOTE: The model of dependency that is embodied in this Association is based solely on the structural relationships within a meta-model. In some cases, the structural dependencies have clear semantic parallels (e.g., the meaning of an Attribute depends on its type). In other cases the semantic parallel is more tenuous (e.g., a DataType only semantically depends on its container in the context of type identity).

   Ends

   dependent

This End is occupied by ModelElements that structurally depend on the ModelElement at the other End.

class:

multiplicity:

changeable:

ModelElement
Zero or more (a ModelElement can have no ModelElement depend on it, or many may depend on it).
no

   provider

This End is occupied by ModelElements that have other ModelElements that structurally depend on them.

class:

multiplicity:

changeable:

ModelElement
Zero or more (a ModelElement can depend on no other ModelElements or multiple ModelElements).
no

   Derivation

   See [S-14] on page 131 . A ModelElement (ME) depends on:

   IDL

   interface DependsOn : Reflective::RefAssociation { DependsOnLinkSet all_depends_on_links () raises (Reflective::MofError); boolean exists (in ModelElement dependent, in ModelElement provider) raises (Reflective::MofError); ModelElementSet dependent (in ModelElement provider) raises (Reflective::MofError); ModelElementSet provider (in ModelElement dependent) raises (Reflective::MofError); };

7.5.10 AttachesTo

   This association represents Tags attached to ModelElements. A ModelElement’s Tags are ordered, although the ordering may not be of any significance, depending on the meaning of the Tags. Ordering is preserved in case some Tags, in conjunction with some defined semantics, requires an ordering.

   Ends

   modelElement

The ModelElements that an attached Tag describes, modifies, or otherwise associates.

class:

multiplicity:

ModelElement
One or more (a Tag must be attached to at least one ModelElement).

   tag

The set of Tags attached to a ModelElement.

class:

multiplicity:

Tag
Zero or more (a ModelElement need not have a Tag), ordered.

   IDL

   interface AttachesTo : Reflective::RefAssociation {

   AttachesToLinkSet all_attaches_to_links ()

   raises (Reflective::MofError);

   boolean exists (in ModelElement model_element, in ::Model::Tag tag)

   raises (Reflective::MofError);

   ModelElementSet model_element (in ::Model::Tag tag)

   raises (Reflective::MofError);

   TagUList tag (in ModelElement model_element)

   raises (Reflective::MofError);

   void add (in ModelElement model_element, in ::Model::Tag tag)

   raises (Reflective::MofError);

   void add_before_tag (in ModelElement model_eleme

   in ::Model::Tag tag,

   in Tag before)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_model_element (in ModelElement model_element, in ::Model::Tag tag,

   in ModelElement new_model_element)

   raises (Reflective::NotFound, Reflective::MofError);

   void modify_tag (in ModelElement model_element,

   in ::Model::Tag tag,

   in Tag new_tag)

   raises (Reflective::NotFound, Reflective::MofError);

   void remove (in ModelElement model_element, in ::Model::Tag tag)

   raises (Reflective::NotFound, Reflective::MofError);

    };