net.sf.farrago.cwm.core
Interface CorePackage
- All Superinterfaces:
- RefBaseObject, RefPackage
- All Known Implementing Classes:
- CorePackage$Hib
public interface CorePackage
- extends RefPackage
Core package interface.
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 interface javax.jmi.reflect.RefPackage |
refAllAssociations, refAllClasses, refAllPackages, refAssociation, refAssociation, refClass, refClass, refCreateStruct, refCreateStruct, refDelete, refGetEnum, refGetEnum, refPackage, refPackage |
getCwmElement
CwmElementClass getCwmElement()
- 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.
- Returns:
- CwmElement class proxy object.
getCwmModelElement
CwmModelElementClass getCwmModelElement()
- 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.
- Returns:
- CwmModelElement class proxy object.
getCwmNamespace
CwmNamespaceClass getCwmNamespace()
- 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.
- Returns:
- CwmNamespace class proxy object.
getCwmClassifier
CwmClassifierClass getCwmClassifier()
- 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.
- Returns:
- CwmClassifier class proxy object.
getCwmClass
CwmClassClass getCwmClass()
- 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.
- Returns:
- CwmClass class proxy object.
getCwmDataType
CwmDataTypeClass getCwmDataType()
- 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.
- Returns:
- CwmDataType class proxy object.
getCwmPackage
CwmPackageClass getCwmPackage()
- 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.
- Returns:
- CwmPackage class proxy object.
getCwmSubsystem
CwmSubsystemClass getCwmSubsystem()
- 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.
- Returns:
- CwmSubsystem class proxy object.
getCwmModel
CwmModelClass getCwmModel()
- 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.
- Returns:
- CwmModel class proxy object.
getCwmFeature
CwmFeatureClass getCwmFeature()
- 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.
- Returns:
- CwmFeature class proxy object.
getCwmStructuralFeature
CwmStructuralFeatureClass getCwmStructuralFeature()
- 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.
- Returns:
- CwmStructuralFeature class proxy object.
getCwmAttribute
CwmAttributeClass getCwmAttribute()
- Returns CwmAttribute class proxy object.
An Attribute describes a named slot within a classifier that may hold
a value.
- Returns:
- CwmAttribute class proxy object.
getCwmConstraint
CwmConstraintClass getCwmConstraint()
- 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.
- Returns:
- CwmConstraint class proxy object.
getCwmDependency
CwmDependencyClass getCwmDependency()
- 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.
- Returns:
- CwmDependency class proxy object.
getCwmExpression
CwmExpressionClass getCwmExpression()
- 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.
- Returns:
- CwmExpression class proxy object.
getCwmBooleanExpression
CwmBooleanExpressionClass getCwmBooleanExpression()
- Returns CwmBooleanExpression class proxy object.
In the metamodel BooleanExpression defines a statement which will
evaluate to an instance of Boolean when it is evaluated.
- Returns:
- CwmBooleanExpression class proxy object.
getCwmProcedureExpression
CwmProcedureExpressionClass getCwmProcedureExpression()
- 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.
- Returns:
- CwmProcedureExpression class proxy object.
getCwmMultiplicity
CwmMultiplicityClass getCwmMultiplicity()
- 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.
- Returns:
- CwmMultiplicity class proxy object.
getCwmMultiplicityRange
CwmMultiplicityRangeClass getCwmMultiplicityRange()
- 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.
- Returns:
- CwmMultiplicityRange class proxy object.
getCwmStereotype
CwmStereotypeClass getCwmStereotype()
- 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.
- Returns:
- CwmStereotype class proxy object.
getCwmTaggedValue
CwmTaggedValueClass getCwmTaggedValue()
- 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.
- Returns:
- CwmTaggedValue class proxy object.
getClassifierFeature
ClassifierFeature getClassifierFeature()
- 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.
- Returns:
- ClassifierFeature association proxy object.
getDependencyClient
DependencyClient getDependencyClient()
- Returns DependencyClient association proxy object.
The DependencyClient association links Dependency instances with
ModelElements that act as clients in the represented dependency
relationship.
- Returns:
- DependencyClient association proxy object.
getDependencySupplier
DependencySupplier getDependencySupplier()
- Returns DependencySupplier association proxy object.
The DependencySupplier association links Dependency instances with
ModelElements that act as suppliers in the represented dependency
relationship.
- Returns:
- DependencySupplier association proxy object.
getElementConstraint
ElementConstraint getElementConstraint()
- 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.
- Returns:
- ElementConstraint association proxy object.
getElementOwnership
ElementOwnership getElementOwnership()
- 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.
- Returns:
- ElementOwnership association proxy object.
getImportedElements
ImportedElements getImportedElements()
- 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.
- Returns:
- ImportedElements association proxy object.
getRangeMultiplicity
RangeMultiplicity getRangeMultiplicity()
- 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.
- Returns:
- RangeMultiplicity association proxy object.
getStereotypeConstraints
StereotypeConstraints getStereotypeConstraints()
- 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.
- Returns:
- StereotypeConstraints association proxy object.
getStereotypedElement
StereotypedElement getStereotypedElement()
- Returns StereotypedElement association proxy object.
The StereotypedElement association links Stereotypes with the
ModelElements to which they apply.
- Returns:
- StereotypedElement association proxy object.
getStereotypeTaggedValues
StereotypeTaggedValues getStereotypeTaggedValues()
- 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.
- Returns:
- StereotypeTaggedValues association proxy object.
getStructuralFeatureType
StructuralFeatureType getStructuralFeatureType()
- 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.
- Returns:
- StructuralFeatureType association proxy object.
getTaggedElement
TaggedElement getTaggedElement()
- 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.
- Returns:
- TaggedElement association proxy object.