net.sf.farrago.cwm.core
Class CorePackage$Hib
java.lang.Object
org.eigenbase.enki.jmi.impl.RefBaseObjectBase
org.eigenbase.enki.jmi.impl.RefPackageBase
org.eigenbase.enki.hibernate.jmi.HibernateRefPackage
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 | d.stereotype.name = "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.
| 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 interface javax.jmi.reflect.RefPackage |
refAllAssociations, refAllClasses, refAllPackages, refAssociation, refAssociation, refClass, refClass, refCreateStruct, refCreateStruct, refDelete, refGetEnum, refGetEnum, refPackage, refPackage |
cwmElementClass
private final CwmElementClass cwmElementClass
cwmModelElementClass
private final CwmModelElementClass cwmModelElementClass
cwmNamespaceClass
private final CwmNamespaceClass cwmNamespaceClass
cwmClassifierClass
private final CwmClassifierClass cwmClassifierClass
cwmClassClass
private final CwmClassClass cwmClassClass
cwmDataTypeClass
private final CwmDataTypeClass cwmDataTypeClass
cwmPackageClass
private final CwmPackageClass cwmPackageClass
cwmSubsystemClass
private final CwmSubsystemClass cwmSubsystemClass
cwmModelClass
private final CwmModelClass cwmModelClass
cwmFeatureClass
private final CwmFeatureClass cwmFeatureClass
cwmStructuralFeatureClass
private final CwmStructuralFeatureClass cwmStructuralFeatureClass
cwmAttributeClass
private final CwmAttributeClass cwmAttributeClass
cwmConstraintClass
private final CwmConstraintClass cwmConstraintClass
cwmDependencyClass
private final CwmDependencyClass cwmDependencyClass
cwmExpressionClass
private final CwmExpressionClass cwmExpressionClass
cwmBooleanExpressionClass
private final CwmBooleanExpressionClass cwmBooleanExpressionClass
cwmProcedureExpressionClass
private final CwmProcedureExpressionClass cwmProcedureExpressionClass
cwmMultiplicityClass
private final CwmMultiplicityClass cwmMultiplicityClass
cwmMultiplicityRangeClass
private final CwmMultiplicityRangeClass cwmMultiplicityRangeClass
cwmStereotypeClass
private final CwmStereotypeClass cwmStereotypeClass
cwmTaggedValueClass
private final CwmTaggedValueClass cwmTaggedValueClass
classifierFeature
private final ClassifierFeature classifierFeature
dependencyClient
private final DependencyClient dependencyClient
dependencySupplier
private final DependencySupplier dependencySupplier
elementConstraint
private final ElementConstraint elementConstraint
elementOwnership
private final ElementOwnership elementOwnership
importedElements
private final ImportedElements importedElements
rangeMultiplicity
private final RangeMultiplicity rangeMultiplicity
stereotypeConstraints
private final StereotypeConstraints stereotypeConstraints
stereotypedElement
private final StereotypedElement stereotypedElement
stereotypeTaggedValues
private final StereotypeTaggedValues stereotypeTaggedValues
structuralFeatureType
private final StructuralFeatureType structuralFeatureType
taggedElement
private final TaggedElement taggedElement
CorePackage$Hib
public CorePackage$Hib(RefPackage container)
addAliasPackages
public void addAliasPackages()
- Overrides:
addAliasPackages in class RefPackageBase
getCwmElement
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
- Returns:
- CwmElement class proxy object.
getCwmModelElement
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
- Returns:
- CwmModelElement class proxy object.
getCwmNamespace
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
- Returns:
- CwmNamespace class proxy object.
getCwmClassifier
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
- Returns:
- CwmClassifier class proxy object.
getCwmClass
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
- Returns:
- CwmClass class proxy object.
getCwmDataType
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
- Returns:
- CwmDataType class proxy object.
getCwmPackage
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
- Returns:
- CwmPackage class proxy object.
getCwmSubsystem
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
- Returns:
- CwmSubsystem class proxy object.
getCwmModel
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
- Returns:
- CwmModel class proxy object.
getCwmFeature
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
- Returns:
- CwmFeature class proxy object.
getCwmStructuralFeature
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
- Returns:
- CwmStructuralFeature class proxy object.
getCwmAttribute
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
- Returns:
- CwmAttribute class proxy object.
getCwmConstraint
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
- Returns:
- CwmConstraint class proxy object.
getCwmDependency
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
- Returns:
- CwmDependency class proxy object.
getCwmExpression
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
- Returns:
- CwmExpression class proxy object.
getCwmBooleanExpression
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
- Returns:
- CwmBooleanExpression class proxy object.
getCwmProcedureExpression
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
- Returns:
- CwmProcedureExpression class proxy object.
getCwmMultiplicity
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
- Returns:
- CwmMultiplicity class proxy object.
getCwmMultiplicityRange
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
- Returns:
- CwmMultiplicityRange class proxy object.
getCwmStereotype
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
- Returns:
- CwmStereotype class proxy object.
getCwmTaggedValue
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
- Returns:
- CwmTaggedValue class proxy object.
getClassifierFeature
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
- Returns:
- ClassifierFeature association proxy object.
getDependencyClient
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
- Returns:
- DependencyClient association proxy object.
getDependencySupplier
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
- Returns:
- DependencySupplier association proxy object.
getElementConstraint
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
- Returns:
- ElementConstraint association proxy object.
getElementOwnership
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
- Returns:
- ElementOwnership association proxy object.
getImportedElements
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
- Returns:
- ImportedElements association proxy object.
getRangeMultiplicity
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
- Returns:
- RangeMultiplicity association proxy object.
getStereotypeConstraints
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
- Returns:
- StereotypeConstraints association proxy object.
getStereotypedElement
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
- Returns:
- StereotypedElement association proxy object.
getStereotypeTaggedValues
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
- Returns:
- StereotypeTaggedValues association proxy object.
getStructuralFeatureType
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
- Returns:
- StructuralFeatureType association proxy object.
getTaggedElement
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
- Returns:
- TaggedElement association proxy object.
checkConstraints
protected void checkConstraints(List<JmiException> errors,
boolean deepVerify)
- Specified by:
checkConstraints in class RefBaseObjectBase