Class CorePackage$Hib

  extended by org.eigenbase.enki.jmi.impl.RefBaseObjectBase
      extended by org.eigenbase.enki.jmi.impl.RefPackageBase
          extended by org.eigenbase.enki.hibernate.jmi.HibernateRefPackage
              extended by net.sf.farrago.cwm.core.CorePackage$Hib
All Implemented Interfaces:
RefBaseObject, RefPackage, CorePackage

public class CorePackage$Hib
extends HibernateRefPackage
implements CorePackage

Core package implementation. The Core metamodel depends on no other packages. The ObjectModel Core metamodel contains basic metamodel classes and associations used by all other CWM metamodel packages, including other ObjectModel packages OCL Representation of Core Constraints Operations The operation allFeatures results in a Set containing all Features of the Classifier itself and all its inherited Features. allFeatures : Set(Feature); allFeatures = self.feature->union(self.parent.oclAsType(Classifier).allFeatures) The operation allAttributes results in a Set containing all Attributes of the Classifier itself and all its inherited Attributes. allAttributes : set(Attribute); allAttributes = self.allFeatures->select(f | f.oclIsKindOf(Attribute)) The operation specification yields the set of Classifiers that the current Classifier realizes. specification: Set(Classifier) specification = self.clientDependency-> select(d | = "realization" and d.supplier.oclIsKindOf(Classifier)).supplier.oclAsType(Classifier) The operation parent returns a Set containing all direct parents of a Classifier. parent : Set(Classifier); parent = self.generalization.parent The operation allParents returns a Set containing all the Classifiers inherited by this Classifier (the transitive closure), excluding the Classifier itself. allParents : Set(Classifier); allParents = self.parent->union(self.parent.allParents) The operation allContents returns a Set containing all ModelElements contained in the Classifier together with the contents inherited from its parents. allContents : Set(ModelElement); allContents = self.contents->union(self.parent.allContents-> select(e | e.elementOwnership.visibility = #public or e.elementOwnership.visibility = #protected)) The operation supplier results in a Set containing all direct suppliers of the ModelElement. supplier : Set(ModelElement); supplier = self.clientDependency.supplier The operation allSuppliers results in a Set containing all the ModelElements that are suppliers of this ModelElement, including the suppliers of these Model Elements. This is the transitive closure. allSuppliers : Set(ModelElement); allSuppliers = self.supplier->union(self.supplier.allSuppliers) The operation contents results in a Set containing all ModelElements contained by the Namespace. contents : Set(ModelElement) contents = self.ownedElement -> union(self.namespace.contents) The operation allContents results in a Set containing all ModelElements contained by the Namespace. allContents : Set(ModelElement); allContents = self.contents The operation allVisibleElements results in a Set containing all ModelElements visible outside of the Namespace. allVisibleElements : Set(ModelElement) allVisibleElements = self.allContents -> select(e | e.elementOwnership.visibility = #public) The operation allSurroundingNamespaces results in a Set containing all surrounding Namespaces. allSurroundingNamespaces : Set(Namespace) allSurroundingNamespaces = self.namespace->union(self.namespace.allSurroundingNamespaces) The operation contents results in a Set containing the ModelElements owned by or imported by the Package. contents : Set(ModelElement) contents = self.ownedElement->union(self.importedElement) The operation allImportedElements results in a Set containing the ModelElements imported by the Package. allImportedElements : Set(ModelElement) allImportedElements = self.importedElement The operation allContents results in a Set containing the ModelElements owned by or imported by the Package. allContents : Set(ModelElement) allContents = self.contents Constraints [C-3-1] A Constraint cannot be applied to itself. context Constraint inv: not self.constrainedElement->includes (self) [C-3-2] A DataType cannot contain any other ModelElements. context DataType inv: self.ownedElement->isEmpty [C-3-3] Tags associated with a model element (directly via a property list or indirectly via a stereotype) must not clash with any meta attributes associated with the model element. context ModelElement inv: -- cannot be specified with OCL

Note: This type should not be subclassed, implemented or directly instantiated by clients. It is generated from a MOF metamodel and implemented by Enki or MDR.

Field Summary
private  ClassifierFeature classifierFeature
private  CwmAttributeClass cwmAttributeClass
private  CwmBooleanExpressionClass cwmBooleanExpressionClass
private  CwmClassClass cwmClassClass
private  CwmClassifierClass cwmClassifierClass
private  CwmConstraintClass cwmConstraintClass
private  CwmDataTypeClass cwmDataTypeClass
private  CwmDependencyClass cwmDependencyClass
private  CwmElementClass cwmElementClass
private  CwmExpressionClass cwmExpressionClass
private  CwmFeatureClass cwmFeatureClass
private  CwmModelClass cwmModelClass
private  CwmModelElementClass cwmModelElementClass
private  CwmMultiplicityClass cwmMultiplicityClass
private  CwmMultiplicityRangeClass cwmMultiplicityRangeClass
private  CwmNamespaceClass cwmNamespaceClass
private  CwmPackageClass cwmPackageClass
private  CwmProcedureExpressionClass cwmProcedureExpressionClass
private  CwmStereotypeClass cwmStereotypeClass
private  CwmStructuralFeatureClass cwmStructuralFeatureClass
private  CwmSubsystemClass cwmSubsystemClass
private  CwmTaggedValueClass cwmTaggedValueClass
private  DependencyClient dependencyClient
private  DependencySupplier dependencySupplier
private  ElementConstraint elementConstraint
private  ElementOwnership elementOwnership
private  ImportedElements importedElements
private  RangeMultiplicity rangeMultiplicity
private  StereotypeConstraints stereotypeConstraints
private  StereotypedElement stereotypedElement
private  StereotypeTaggedValues stereotypeTaggedValues
private  StructuralFeatureType structuralFeatureType
private  TaggedElement taggedElement
Constructor Summary
CorePackage$Hib(RefPackage container)
Method Summary
 void addAliasPackages()
protected  void checkConstraints(List<JmiException> errors, boolean deepVerify)
 ClassifierFeature getClassifierFeature()
          Returns ClassifierFeature association proxy object.
 CwmAttributeClass getCwmAttribute()
          Returns CwmAttribute class proxy object.
 CwmBooleanExpressionClass getCwmBooleanExpression()
          Returns CwmBooleanExpression class proxy object.
 CwmClassClass getCwmClass()
          Returns CwmClass class proxy object.
 CwmClassifierClass getCwmClassifier()
          Returns CwmClassifier class proxy object.
 CwmConstraintClass getCwmConstraint()
          Returns CwmConstraint class proxy object.
 CwmDataTypeClass getCwmDataType()
          Returns CwmDataType class proxy object.
 CwmDependencyClass getCwmDependency()
          Returns CwmDependency class proxy object.
 CwmElementClass getCwmElement()
          Returns CwmElement class proxy object.
 CwmExpressionClass getCwmExpression()
          Returns CwmExpression class proxy object.
 CwmFeatureClass getCwmFeature()
          Returns CwmFeature class proxy object.
 CwmModelClass getCwmModel()
          Returns CwmModel class proxy object.
 CwmModelElementClass getCwmModelElement()
          Returns CwmModelElement class proxy object.
 CwmMultiplicityClass getCwmMultiplicity()
          Returns CwmMultiplicity class proxy object.
 CwmMultiplicityRangeClass getCwmMultiplicityRange()
          Returns CwmMultiplicityRange class proxy object.
 CwmNamespaceClass getCwmNamespace()
          Returns CwmNamespace class proxy object.
 CwmPackageClass getCwmPackage()
          Returns CwmPackage class proxy object.
 CwmProcedureExpressionClass getCwmProcedureExpression()
          Returns CwmProcedureExpression class proxy object.
 CwmStereotypeClass getCwmStereotype()
          Returns CwmStereotype class proxy object.
 CwmStructuralFeatureClass getCwmStructuralFeature()
          Returns CwmStructuralFeature class proxy object.
 CwmSubsystemClass getCwmSubsystem()
          Returns CwmSubsystem class proxy object.
 CwmTaggedValueClass getCwmTaggedValue()
          Returns CwmTaggedValue class proxy object.
 DependencyClient getDependencyClient()
          Returns DependencyClient association proxy object.
 DependencySupplier getDependencySupplier()
          Returns DependencySupplier association proxy object.
 ElementConstraint getElementConstraint()
          Returns ElementConstraint association proxy object.
 ElementOwnership getElementOwnership()
          Returns ElementOwnership association proxy object.
 ImportedElements getImportedElements()
          Returns ImportedElements association proxy object.
 RangeMultiplicity getRangeMultiplicity()
          Returns RangeMultiplicity association proxy object.
 StereotypeConstraints getStereotypeConstraints()
          Returns StereotypeConstraints association proxy object.
 StereotypedElement getStereotypedElement()
          Returns StereotypedElement association proxy object.
 StereotypeTaggedValues getStereotypeTaggedValues()
          Returns StereotypeTaggedValues association proxy object.
 StructuralFeatureType getStructuralFeatureType()
          Returns StructuralFeatureType association proxy object.
 TaggedElement getTaggedElement()
          Returns TaggedElement association proxy object.
Methods inherited from class org.eigenbase.enki.hibernate.jmi.HibernateRefPackage
getHibernateRepository, refDelete
Methods inherited from class org.eigenbase.enki.jmi.impl.RefPackageBase
addAssociation, addClass, addPackage, getRepository, refAllAssociations, refAllClasses, refAllPackages, refAssociation, refAssociation, refClass, refClass, refCreateStruct, refCreateStruct, refGetEnum, refGetEnum, refImmediatePackage, refPackage, refPackage
Methods inherited from class org.eigenbase.enki.jmi.impl.RefBaseObjectBase
createInstance, equals, getCurrentInitializer, getEnum, getInitializer, getMofId, getTag, hashCode, invokeMethod, invokeMethod, logJmi, refMetaObject, refMofId, refOutermostPackage, refVerifyConstraints, setMofId, setRefMetaObject
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface javax.jmi.reflect.RefPackage
refAllAssociations, refAllClasses, refAllPackages, refAssociation, refAssociation, refClass, refClass, refCreateStruct, refCreateStruct, refDelete, refGetEnum, refGetEnum, refPackage, refPackage
Methods inherited from interface javax.jmi.reflect.RefBaseObject
equals, hashCode, refImmediatePackage, refMetaObject, refMofId, refOutermostPackage, refVerifyConstraints

Field Detail


private final CwmElementClass cwmElementClass


private final CwmModelElementClass cwmModelElementClass


private final CwmNamespaceClass cwmNamespaceClass


private final CwmClassifierClass cwmClassifierClass


private final CwmClassClass cwmClassClass


private final CwmDataTypeClass cwmDataTypeClass


private final CwmPackageClass cwmPackageClass


private final CwmSubsystemClass cwmSubsystemClass


private final CwmModelClass cwmModelClass


private final CwmFeatureClass cwmFeatureClass


private final CwmStructuralFeatureClass cwmStructuralFeatureClass


private final CwmAttributeClass cwmAttributeClass


private final CwmConstraintClass cwmConstraintClass


private final CwmDependencyClass cwmDependencyClass


private final CwmExpressionClass cwmExpressionClass


private final CwmBooleanExpressionClass cwmBooleanExpressionClass


private final CwmProcedureExpressionClass cwmProcedureExpressionClass


private final CwmMultiplicityClass cwmMultiplicityClass


private final CwmMultiplicityRangeClass cwmMultiplicityRangeClass


private final CwmStereotypeClass cwmStereotypeClass


private final CwmTaggedValueClass cwmTaggedValueClass


private final ClassifierFeature classifierFeature


private final DependencyClient dependencyClient


private final DependencySupplier dependencySupplier


private final ElementConstraint elementConstraint


private final ElementOwnership elementOwnership


private final ImportedElements importedElements


private final RangeMultiplicity rangeMultiplicity


private final StereotypeConstraints stereotypeConstraints


private final StereotypedElement stereotypedElement


private final StereotypeTaggedValues stereotypeTaggedValues


private final StructuralFeatureType structuralFeatureType


private final TaggedElement taggedElement
Constructor Detail


public CorePackage$Hib(RefPackage container)
Method Detail


public void addAliasPackages()
addAliasPackages in class RefPackageBase


public CwmElementClass getCwmElement()
Description copied from interface: CorePackage
Returns CwmElement class proxy object. An element is an atomic constituent of a model. In the metamodel, an Element is the top metaclass in the metaclass hierarchy. Element is an abstract metaclass.

Specified by:
getCwmElement in interface CorePackage
CwmElement class proxy object.


public CwmModelElementClass getCwmModelElement()
Description copied from interface: CorePackage
Returns CwmModelElement class proxy object. A model element is an element that is an abstraction drawn from the system being modeled. In the metamodel, a ModelElement is a named entity in a Model. It is the base for all modeling metaclasses in the CWM. All other modeling metaclasses are either direct or indirect subclasses of ModelElement.

Specified by:
getCwmModelElement in interface CorePackage
CwmModelElement class proxy object.


public CwmNamespaceClass getCwmNamespace()
Description copied from interface: CorePackage
Returns CwmNamespace class proxy object. 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. In the metamodel, a Namespace is a ModelElement that can own other ModelElements, such as Classifiers. The name of each owned ModelElement must be unique within the Namespace. Moreover, each contained ModelElement is owned by at most one Namespace. The concrete subclasses of Namespace may have additional constraints on which kind of elements may be contained. Namespace is an abstract metaclass. Note that explicit parts of a model element, such as the features of a Classifier, are not modeled as owned elements in a namespace. A namespace is used for unstructured contents such as the contents of a package, or a class declared inside the scope of another class.

Specified by:
getCwmNamespace in interface CorePackage
CwmNamespace class proxy object.


public CwmClassifierClass getCwmClassifier()
Description copied from interface: CorePackage
Returns CwmClassifier class proxy object. A classifier is an element that describes structural and behavioral features; it comes in several specific forms, including class, data type, interface, component, and others that are defined in other metamodel packages. Classifier is often used as a type. In the metamodel, a Classifier may declare a collection of Features, such as Attributes, Operations and Methods. It has a name, which is unique in the Namespace enclosing the Classifier. Classifier is an abstract metaclass. Classifier is a child of Namespace. As a Namespace, a Classifier may declare other Classifiers nested in its scope. Nested Classifiers may be accessed by other Classifiers only if the nested Classifiers have adequate visibility. There are no data value or state consequences of nested Classifiers, i.e., it is not an aggregation or composition.

Specified by:
getCwmClassifier in interface CorePackage
CwmClassifier class proxy object.


public CwmClassClass getCwmClass()
Description copied from interface: CorePackage
Returns CwmClass class proxy object. A class is a description of a set of objects that share the same attributes, operations, methods, relationships, and semantics. A class may use a set of interfaces to specify collections of operations it provides to its environment. In the metamodel, a Class describes a set of objects sharing a collection of Features that are common to the set of objects. The purpose of a Class is to declare a collection of Features that fully describe the structure and behavior of objects. Some Classes may not be directly instantiated. These Classes are said to be abstract and exist only for other Classes to inherit and reuse the Features declared by them. No object may be a direct instance of an abstract Class, although an object may be an indirect instance of one through a subclass that is non-abstract. A Class acts as the namespace for various kinds of contained elements defined within its scope, including classes, interfaces and associations (note that this is purely a scoping construction and does not imply anything about aggregation). The contained classes can be used as ordinary classes in the container class. If a class inherits another class, the contents of the ancestor are available to its descendents if the visibility of an element is public or protected; however, if the visibility is private, then the element is not visible and therefore not available in the descendant.

Specified by:
getCwmClass in interface CorePackage
CwmClass class proxy object.


public CwmDataTypeClass getCwmDataType()
Description copied from interface: CorePackage
Returns CwmDataType class proxy object. A data type is a type whose values have no identity (i.e., they are pure values). Data types include primitive built-in types (such as integer and string) as well as definable enumeration types. In the metamodel, a DataType defines a special kind of Classifier in which operations are all pure functions (i.e., they can return data values but they cannot change data values, because they have no identity). For example, an "add" operation on a number with another number as an argument yields a third number as a result; the target and argument are unchanged. A DataType is a special kind of Classifier whose instances are primitive values, not objects. For example, integers and strings are usually treated as primitive values. A primitive value does not have an identity, so two occurrences of the same value cannot be differentiated. Usually, DataTypes are used for specification of the type of an attribute or parameter.

Specified by:
getCwmDataType in interface CorePackage
CwmDataType class proxy object.


public CwmPackageClass getCwmPackage()
Description copied from interface: CorePackage
Returns CwmPackage class proxy object. A package is a grouping of model elements. In the metamodel, Package is a subclass of Namespace. A Package contains ModelElements such as Packages and Classifiers. A Package may also contain Constraints and Dependencies between ModelElements of the Package. The purpose of the package construct is to provide a general grouping mechanism. In fact, its only semantics is to define a namespace for its contents. The package construct can be used for organizing elements for any purpose; the criteria to use for grouping elements together into one package are not defined. A package owns a set of model elements, with the implication that if the package is removed from the model, so are the elements owned by the package. Elements with names, such as classifiers, that are owned by the same package must have unique names within the package, although elements in different packages may have the same name. There may be relationships between elements contained in the same package, and between an element in one package and an element in a surrounding package at any level. In other words, elements ?see? all the way out through nested levels of packages. Elements in peer packages, however, are encapsulated and are not a priori visible to each other. The same goes for elements in contained packages, i.e. packages do not see "inwards". Elements owned by a Package can be made available to other Packages by importing them. Although any ModelElement may be imported by a Package, imported ModelElements are typically other Packages. When an element is imported by a package it extends the namespace of that package. Thus the elements available in a Package consists of its owned and imported ModelElements.

Specified by:
getCwmPackage in interface CorePackage
CwmPackage class proxy object.


public CwmSubsystemClass getCwmSubsystem()
Description copied from interface: CorePackage
Returns CwmSubsystem class proxy object. A subsystem is a grouping of model elements that represents a behavioral unit in a physical system. A subsystem offers interfaces and has operations. In the metamodel, Subsystem is a subclass of both Package and Classifier. As such it may have a set of Features. The purpose of the subsystem construct is to provide a grouping mechanism for specifying a behavioral unit of a physical system. Apart from defining a namespace for its contents, a subsystem serves as a specification unit for the behavior of its contained model elements. The contents of a subsystem is defined in the same way as for a package, thus it consists of owned elements and imported elements, with unique names within the subsystem.

Specified by:
getCwmSubsystem in interface CorePackage
CwmSubsystem class proxy object.


public CwmModelClass getCwmModel()
Description copied from interface: CorePackage
Returns CwmModel class proxy object. A model captures a view of a physical system. It is an abstraction of the physical system, with a certain purpose. 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. In the metamodel, Model is a subclass of Package. It contains a containment hierarchy of ModelElements that together describe the physical system. A Model also contains a set of ModelElements that represents the environment of the system. Different Models can be defined for the same physical system, where each model represents a view of the physical system defined by its purpose and abstraction level, e.g. an analysis model, a design model, an implementation model. Typically different models are complementary and defined from the perspectives (viewpoints) of different system stakeholders.

Specified by:
getCwmModel in interface CorePackage
CwmModel class proxy object.


public CwmFeatureClass getCwmFeature()
Description copied from interface: CorePackage
Returns CwmFeature class proxy object. A feature is a property, like attribute or operation, which is encapsulated within a Classifier. In the metamodel, a Feature declares a structural or behavioral characteristic of an instance of a Classifier or of the Classifier itself. Feature is an abstract metaclass.

Specified by:
getCwmFeature in interface CorePackage
CwmFeature class proxy object.


public CwmStructuralFeatureClass getCwmStructuralFeature()
Description copied from interface: CorePackage
Returns CwmStructuralFeature class proxy object. A structural feature refers to a static feature of a model element. In the metamodel, a StructuralFeature declares a structural aspect of a Classifier that is typed, such as an attribute. For example, it specifies the multiplicity and changeability of the StructuralFeature. StructuralFeature is an abstract metaclass.

Specified by:
getCwmStructuralFeature in interface CorePackage
CwmStructuralFeature class proxy object.


public CwmAttributeClass getCwmAttribute()
Description copied from interface: CorePackage
Returns CwmAttribute class proxy object. An Attribute describes a named slot within a classifier that may hold a value.

Specified by:
getCwmAttribute in interface CorePackage
CwmAttribute class proxy object.


public CwmConstraintClass getCwmConstraint()
Description copied from interface: CorePackage
Returns CwmConstraint class proxy object. A constraint is a semantic condition or restriction expressed in text. In the metamodel, a Constraint is a BooleanExpression on an associated ModelElement(s) which must be true for the model to be well formed. This restriction can be stated in natural language, or in different kinds of languages with well-defined semantics. Certain Constraints are predefined, others may be user defined. Note that a Constraint is an assertion, not an executable mechanism. The specification is written as an expression in a designated constraint language. The language can be specially designed for writing constraints (such as OCL), a programming language, mathematical notation, or natural language. If constraints are to be enforced by a model editor tool, then the tool must understand the syntax and semantics of the constraint language. Because the choice of language is arbitrary, constraints can be used as an extension mechanism. The constraint concept allows new semantics to be specified linguistically for a model element. In the metamodel a Constraint directly attached to a ModelElement describes semantic restrictions that this ModelElement must obey.

Specified by:
getCwmConstraint in interface CorePackage
CwmConstraint class proxy object.


public CwmDependencyClass getCwmDependency()
Description copied from interface: CorePackage
Returns CwmDependency class proxy object. A dependency states that the implementation or functioning of one or more elements requires the presence of one or more other elements. In the metamodel, a Dependency is a directed relationship from a client (or clients) to a supplier (or suppliers) stating that the client is dependent on the supplier (i.e., the client element requires the presence and knowledge of the supplier element). A dependency specifies that the semantics of a set of model elements requires the presence of another set of model elements. This implies that if the source is somehow modified, the dependents probably must be modified. The reason for the dependency can be specified in several different ways (e.g., using natural language or an algorithm) but is often implicit. Whenever the supplier element of a dependency changes, the client element is potentially invalidated. After such invalidation, a check should be performed followed by possible changes to the derived client element. Such a check should be performed after which action can be taken to change the derived element to validate it again.

Specified by:
getCwmDependency in interface CorePackage
CwmDependency class proxy object.


public CwmExpressionClass getCwmExpression()
Description copied from interface: CorePackage
Returns CwmExpression class proxy object. In the metamodel an Expression defines a statement which will evaluate to a (possibly empty) set of instances when executed in a context. An Expression does not modify the environment in which it is evaluated. An expression contains an expression string and the name of an interpretation language with which to evaluate the string.

Specified by:
getCwmExpression in interface CorePackage
CwmExpression class proxy object.


public CwmBooleanExpressionClass getCwmBooleanExpression()
Description copied from interface: CorePackage
Returns CwmBooleanExpression class proxy object. In the metamodel BooleanExpression defines a statement which will evaluate to an instance of Boolean when it is evaluated.

Specified by:
getCwmBooleanExpression in interface CorePackage
CwmBooleanExpression class proxy object.


public CwmProcedureExpressionClass getCwmProcedureExpression()
Description copied from interface: CorePackage
Returns CwmProcedureExpression class proxy object. In the metamodel ProcedureExpression defines a statement which will result in a change to the values of its environment when it is evaluated.

Specified by:
getCwmProcedureExpression in interface CorePackage
CwmProcedureExpression class proxy object.


public CwmMultiplicityClass getCwmMultiplicity()
Description copied from interface: CorePackage
Returns CwmMultiplicity class proxy object. In the metamodel a Multiplicity defines a non-empty set of non-negative integers. A set which only contains zero ({0}) is not considered a valid Multiplicity. Every Multiplicity has at least one corresponding String representation.

Specified by:
getCwmMultiplicity in interface CorePackage
CwmMultiplicity class proxy object.


public CwmMultiplicityRangeClass getCwmMultiplicityRange()
Description copied from interface: CorePackage
Returns CwmMultiplicityRange class proxy object. In the metamodel a MultiplicityRange defines a range of integers. The upper bound of the range cannot be below the lower bound. The lower bound must be a nonnegative integer. The upper bound must be a nonnegative integer or the special value unlimited, which indicates there is no upper bound on the range.

Specified by:
getCwmMultiplicityRange in interface CorePackage
CwmMultiplicityRange class proxy object.


public CwmStereotypeClass getCwmStereotype()
Description copied from interface: CorePackage
Returns CwmStereotype class proxy object. The stereotype concept provides a way of branding (classifying) model elements so that they behave as if they were instances of new virtual metamodel constructs. These model elements have the same structure (attributes, associations, operations) as similar non-stereotyped model elements of the same kind. The stereotype may specify additional constraints and required tagged values that apply to model elements. In addition, a stereotype may be used to indicate a difference in meaning or usage between two model elements with identical structure. In the metamodel the Stereotype metaclass is a subclass of ModelElement. Tagged Values and Constraints attached to a Stereotype apply to all ModelElements branded by that Stereotype. A stereotype keeps track of the base class to which it may be applied. The base class is a class in the metamodel (not a user-level modeling element) such as Class, Association, etc. If a model element is branded by an attached stereotype, then the CWM base class of the model element must be the base class specified by the stereotype or one of the subclasses of that base class.

Specified by:
getCwmStereotype in interface CorePackage
CwmStereotype class proxy object.


public CwmTaggedValueClass getCwmTaggedValue()
Description copied from interface: CorePackage
Returns CwmTaggedValue class proxy object. A tagged value allows information to be attached to any model element in the form of a "tagged value" pair (i.e., name = value). The interpretation of tagged value semantics is intentionally beyond the scope of CWM. It must be determined by user or tool conventions. It is expected that tools will define tags to supply information needed for their operations beyond the basic semantics of CWM. Such information could include code generation options, model management information, or user-specified semantics. Even though TaggedValues are a simple and straightforward extension technique, their use restricts semantic interchange of metadata to only those tools that share a common understanding of the specific tagged value names.

Specified by:
getCwmTaggedValue in interface CorePackage
CwmTaggedValue class proxy object.


public ClassifierFeature getClassifierFeature()
Description copied from interface: CorePackage
Returns ClassifierFeature association proxy object. The ClassifierFeature association provides a composite aggregation containment relationship between Classifiers and the Features they own. The feature end of the association is ordered allowing preservation of the ordering of Features within their owning Classifier. A Feature can be owned by at most one Classifier. The optional character of ownership is intended as a convenience to tools, allowing them to create Features prior to linking them to their owning Classifier.

Specified by:
getClassifierFeature in interface CorePackage
ClassifierFeature association proxy object.


public DependencyClient getDependencyClient()
Description copied from interface: CorePackage
Returns DependencyClient association proxy object. The DependencyClient association links Dependency instances with ModelElements that act as clients in the represented dependency relationship.

Specified by:
getDependencyClient in interface CorePackage
DependencyClient association proxy object.


public DependencySupplier getDependencySupplier()
Description copied from interface: CorePackage
Returns DependencySupplier association proxy object. The DependencySupplier association links Dependency instances with ModelElements that act as suppliers in the represented dependency relationship.

Specified by:
getDependencySupplier in interface CorePackage
DependencySupplier association proxy object.


public ElementConstraint getElementConstraint()
Description copied from interface: CorePackage
Returns ElementConstraint association proxy object. The ElementConstraint association provides linkages between ModelElements and the Constraint instances that constrain their state. Note that a Constraint instance may not simultaneously participate in both the ElementConstraint and the StereotypeConstraint associations.

Specified by:
getElementConstraint in interface CorePackage
ElementConstraint association proxy object.


public ElementOwnership getElementOwnership()
Description copied from interface: CorePackage
Returns ElementOwnership association proxy object. The ElementOwnership association identifies ModelElements owned by Namespaces. ModelElements may be owned by at most one Namespace. Refer to the above discussion of the Namespace class for more information on the nature of the ownership relationship between Namespaces and ModelElements.

Specified by:
getElementOwnership in interface CorePackage
ElementOwnership association proxy object.


public ImportedElements getImportedElements()
Description copied from interface: CorePackage
Returns ImportedElements association proxy object. The ImportedElements association identifies ModelElements that a Package instance imports from other Namespaces. Although any ModelElement may be imported by a Package, imported ModelElements are typically other Packages or aggregate Classifiers, such as Class instances.

Specified by:
getImportedElements in interface CorePackage
ImportedElements association proxy object.


public RangeMultiplicity getRangeMultiplicity()
Description copied from interface: CorePackage
Returns RangeMultiplicity association proxy object. The RangeMultiplicity association identifies the set of MultiplicityRange instances that specify the lower and upper bounds of individual cardinality ranges defined by a Multiplicity instance. A MultiplicityRange instance must be owned by a single Multiplicity instance.

Specified by:
getRangeMultiplicity in interface CorePackage
RangeMultiplicity association proxy object.


public StereotypeConstraints getStereotypeConstraints()
Description copied from interface: CorePackage
Returns StereotypeConstraints association proxy object. The StereotypeConstraints association links Stereotypes with Constraints that further restrict the states that a stereotyped ModelElement may assume. A Constraint instance may not simultaneously participate in both the StereotypeContraints association and the ElementConstraint association.

Specified by:
getStereotypeConstraints in interface CorePackage
StereotypeConstraints association proxy object.


public StereotypedElement getStereotypedElement()
Description copied from interface: CorePackage
Returns StereotypedElement association proxy object. The StereotypedElement association links Stereotypes with the ModelElements to which they apply.

Specified by:
getStereotypedElement in interface CorePackage
StereotypedElement association proxy object.


public StereotypeTaggedValues getStereotypeTaggedValues()
Description copied from interface: CorePackage
Returns StereotypeTaggedValues association proxy object. The StereotypeTaggedValues association links Stereotypes with the set of TaggedValues they require. TaggedValues cannot simultaneously participate in both the TaggedElement and StereotypeTaggedValues associations.

Specified by:
getStereotypeTaggedValues in interface CorePackage
StereotypeTaggedValues association proxy object.


public StructuralFeatureType getStructuralFeatureType()
Description copied from interface: CorePackage
Returns StructuralFeatureType association proxy object. The StructuralFeatureType association identifies the Classifier instance that defines the type of particular StructuralFeatures. A StructuralFeature instance must have a Classifier instance that defines its type.

Specified by:
getStructuralFeatureType in interface CorePackage
StructuralFeatureType association proxy object.


public TaggedElement getTaggedElement()
Description copied from interface: CorePackage
Returns TaggedElement association proxy object. The TaggedElement association links TaggedValues with the ModelElements that own them. TaggedValues cannot simultaneously participate in both the TaggedElement and StereotypeTaggedValues associations.

Specified by:
getTaggedElement in interface CorePackage
TaggedElement association proxy object.


protected void checkConstraints(List<JmiException> errors,
                                boolean deepVerify)
Specified by:
checkConstraints in class RefBaseObjectBase