Constructs
type: Ontology
publisher: Telecommunications Software and Systems Group 'www.tssg.org'
contributor: Nazim Agoulmine - Laboratoire de Réseaux et Systèmes Multimédia - Université d'Evry-Val d'Essonne @fr
contributor: John Strassner - Autonomic Research Lab - Motorola Labs
contributor: Mícheál Ó Foghlú - Telecommunications Software and Systems Group - Waterford Institute of Technology
creator: Elyes Lehtihet 'elehtihet@tssg.org'
date: 29/05/2005
subject: Unified Modeling Language (UML2) Superstructure
imports: http://purl.org/dc/elements/1.1/
imports: PrimitiveTypes.owl
imports: TypedElements.owl
imports: Visibilities.owl
imports: Expressions.owl
imports: StructuralFeatures.owl
imports: Kernel.owl
imports: Constraints.owl
imports: Comments.owl
imports: Basic.owl
imports: Changeabilities.owl
imports: Super.owl
imports: Relationships.owl
imports: Ownerships.owl
imports: BehavioralFeatures.owl
imports: Classifiers.owl
imports: Namespaces.owl
imports: Multiplicities.owl
imports: Redefinitions.owl
imports: Abstractions.owl

EnumerationLiteral
type: Class
subclass of: NamedElement
subclass of: Restriction
  on property: EnumerationLiteral.enumeration
  max cardinality: 1

Package
type: Class
subclass of: PackageableElement
subclass of: Namespace
comment: Operation::elements_public_or_private self.ownedElements->forAll(e | e.visibility->notEmpty() implies e.visbility = #public or e.visibility = #private)
comment: Operation::mustBeOwned false
comment: Operation::visibleMembers member->select( m | self.makesVisible(m))
comment: Operation::makesVisible el.visibility->isEmpty() or el.visibility = #public
subclass of: Restriction
  on property: Package.nestingPackage
  max cardinality: 1

DataType
type: Class
subclass of: Classifier
comment: Operation::inherit inhs->excluding(inh | ownedMember->select(oclIsKindOf(RedefinableElement))->select(redefinedElement->includes(inh)))

Class
subclass of: Classifier
comment: Operation::inherit inhs->excluding(inh | ownedMember->select(oclIsKindOf(RedefinableElement))->select(redefinedElement->includes(inh)))

Association
type: Class
subclass of: Classifier
subclass of: Relationship
subclass of: Restriction
  on property: Association.memberEnd
  min cardinality: 2
subclass of: Restriction
  on property: Association.endType
  min cardinality: 1

TypedElement
type: Class
subclass of: NamedElement
subclass of: Restriction
  on property: TypedElement.type
  max cardinality: 1

Relationship
type: Class
subclass of: Element
subclass of: Restriction
  on property: Relationship.relatedElement
  min cardinality: 1

NamedElement
type: Class
subclass of: Element
subclass of: Restriction
  on property: NamedElement.namespace
  max cardinality: 1

Type
type: Class
subclass of: NamedElement
subclass of: PackageableElement
subclass of: Restriction
  on property: Type.package
  max cardinality: 1

DirectedRelationship
type: Class
subclass of: Relationship
subclass of: Restriction
  on property: DirectedRelationship.target
  min cardinality: 1
subclass of: Restriction
  on property: DirectedRelationship.source
  min cardinality: 1

Operation
type: Class
subclass of: BehavioralFeature
comment: Operation::type_of_result if returnResult->size() = 1 then type = returnResult.type else type = nil endif
comment: Operation::isOrdered if returnResult->size() = 1 then returnResult->any().isOrdered else false endif
comment: Operation::isUnique if returnResult->size() = 1 then returnResult->any().isUnique else true endif
comment: Operation::lower if returnResult->size() = 1 then returnResult->any().lower else Set{} endif
comment: Operation::upper if returnResult->size() = 1 then returnResult->any().upper else Set{} endif
comment: Operation::type if returnResult->size() = 1 then returnResult->any().type else Set{} endif
comment: Operation::only_body_for_query bodyCondition->notEmpty() implies isQuery
comment: Operation::isConsistentWith (redefinee.oclIsKindOf(Operation) and let op: Operation = redefinee.oclAsType(Operation) in self.formalParameter.size() = op.formalParameter.size() and self.returnResult.size() = op.returnResult.size() and forAll(i | op.formalParameter[i].type.conformsTo(self.formalParameter[i].type)) and forAll(i | op.returnResult[i].type.conformsTo(self.returnResult[i].type)) )
subclass of: Restriction
  on property: Operation.type
  max cardinality: 1
subclass of: Restriction
  on property: Operation.class
  max cardinality: 1
subclass of: Restriction
  on property: Operation.datatype
  max cardinality: 1
subclass of: Restriction
  on property: Operation.bodyCondition
  max cardinality: 1

Classifier
type: Class
subclass of: Namespace
subclass of: Type
comment: Operation::conformsTo (self=other) or (self.allParents()->includes(other))

PackageImport
type: Class
subclass of: DirectedRelationship
comment: Operation::public_or_private self.visibility = #public or self.visibility = #private

ElementImport
type: Class
subclass of: DirectedRelationship
comment: Operation::visibility_public_or_private self.visibility = #public or self.visibility = #private
comment: Operation::imported_element_is_public self.importedElement.visibility.notEmpty() implies self.importedElement.visibility = #public
comment: Operation::getName if self.alias->notEmpty() then self.alias else self.importedElement.name endif

BehavioralFeature
type: Class
subclass of: Feature
subclass of: Namespace
comment: Operation::isDistinguishableFrom if n.oclIsKindOf(BehavioralFeature) then if ns.getNamesOfMember(self)->intersection(ns.getNamesOfMember(n))->notEmpty() then Set{}->include(self)->include(n)->isUnique( bf | bf.parameter->collect(type)) else true endif else true endif

Parameter
type: Class
subclass of: Parameter
subclass of: TypedElement
subclass of: MultiplicityElement
subclass of: Restriction
  on property: Parameter.operation
  max cardinality: 1

Property
type: Class
subclass of: StructuralFeature
comment: Operation::opposite_is_other_end opposite = if owningAssociation->notEmpty() and association.memberEnd->size() = 2 then let otherEnd = (association.memberEnd - self)->any() in if otherEnd.owningAssociation->notEmpty then otherEnd else Set{} endif else Set {} endif
comment: Operation::opposite if owningAssociation->notEmpty() and association.memberEnd->size() = 2 then let otherEnd = (association.memberEnd - self)->any() in if otherEnd.owningAssociation->notEmpty then otherEnd else Set{} endif else Set {} endif
comment: Operation::multiplicity_of_composite isComposite implies (upperBound()->isEmpty() or upperBound() <= 1)
comment: Operation::subsetting_context subsettedProperty->notEmpty() implies (subsettingContext()->notEmpty() and subsettingContext()->forAll (sc | subsettedProperty->forAll(sp | sp.subsettingContext()->exists(c | sc.conformsTo(c)))))
comment: Operation::navigable_property_redefinition (subsettedProperty->exists(sp | sp.class->notEmpty()) implies class->notEmpty()) and (redefinedProperty->exists(rp | rp.class->notEmpty()) implies class->notEmpty())
comment: Operation::subsetting_rules subsettedProperty->forAll(sp | type.conformsTo(sp.type) and ((upperBound()->notEmpty() and sp.upperBound()->notEmpty()) implies upperBound()<=sp.upperBound() ))
comment: Operation::navigable_readonly isReadOnly implies class->notEmpty()
comment: Operation::derivedUnion_is_derived isDerivedUnion implies isDerived
comment: Operation::isConsistentWith (redefinee.oclIsKindOf(Property) and let prop: Property = redefinee.oclAsType(Property) in type.conformsTo(prop.type) and (lowerBound()->notEmpty and prop.lowerBound()->notEmpty() implies lowerBound() >= prop.lowerBound()) and (upperBound()->notEmpty and prop.upperBound()->notEmpty() implies upperBound() <= prop.upperBound()) and (prop.isDerived implies isDerived))
comment: Operation::subsettingContext if association->notEmpty() then association.endType-type else if classifier->notEmpty then Set{classifier} else Set{} endif endif
subclass of: Restriction
  on property: Property.opposite
  max cardinality: 1
subclass of: Restriction
  on property: Property.association
  max cardinality: 1
subclass of: Restriction
  on property: Property.owningAssociation
  max cardinality: 1
subclass of: Restriction
  on property: Property.class
  max cardinality: 1
subclass of: Restriction
  on property: Property.datatype
  max cardinality: 1

Namespace
type: Class
subclass of: NamedElement
comment: Operation::importedMember_derived self.importedMember->includesAll(self.importedMembers(self.elementImport.importedElement.asSet()->union(self.packageImport.importedPackage->collect(p | p.visibleMembers()))))
comment: Operation::importedMember self.importedMembers(self.elementImport.importedElement.asSet()->union(self.packageImport.importedPackage->collect(p | p.visibleMembers())))
comment: Operation::getNamesOfMember if self.ownedMember->includes(element) then Set{}->include(element.name) else let elementImports: ElementImport = self.elementImport->select(ei | ei.importedElement = element) in if elementImports->notEmpty() then elementImports->collect(el | el.getName()) else self.packageImport->select(pi | pi.importedPackage.visibleMembers()->includes(element))->collect(pi | pi.importedPackage.getNamesOfMember(element)) endif endif
comment: Operation::importMembers self.excludeCollisions(imps)->select(imp | self.ownedMember->forAll(mem | mem.imp.isDistinguishableFrom(mem, self)))
comment: Operation::excludeCollisions imps->reject(imp1 | imps.exists(imp2 | not imp1.isDistinguishableFrom(imp2, self)))

Feature
type: Class
subclass of: RedefinableElement
subclass of: Restriction
  on property: Feature.featuringClassifier
  min cardinality: 1

Constraint
type: Class
subclass of: PackageableElement
subclass of: Restriction
  on property: Constraint.namespace
  max cardinality: 1
subclass of: Restriction
  on property: Constraint.context
  max cardinality: 1

Element
type: Class
subclass of: Restriction
  on property: Element.owner
  max cardinality: 1

Element.ownedElement
type: ObjectProperty
domain: Element
range: Element
comment: union

Element.owner
type: ObjectProperty
domain: Element
range: Element
comment: union

Namespace.ownedRule
type: ObjectProperty
domain: Namespace
range: Constraint
comment: subsets ownedMember

PackageMerge.mergedPackage
type: ObjectProperty
type: FunctionalProperty
domain: PackageMerge
range: Package
comment: subsets target

Constraint.namespace
type: ObjectProperty
domain: Constraint
range: Namespace
comment: subsets context

Constraint.context
type: ObjectProperty
domain: Constraint
range: Namespace
comment: union

PackageMerge.receivingPackage
type: ObjectProperty
type: FunctionalProperty
domain: PackageMerge
range: Package
comment: subsets source, subsets owner

Package.packageMerge
type: ObjectProperty
domain: Package
range: PackageMerge
comment: subsets ownedElement

Parameter.operation
type: ObjectProperty
domain: Parameter
range: Operation
comment: subsets ownerFormalParameter

Classifier.feature
type: ObjectProperty
domain: Classifier
range: Feature
comment: union, subsets member

Feature.featuringClassifier
type: ObjectProperty
domain: Feature
range: Classifier
comment: union

Association.navigableOwnedEnd
type: ObjectProperty
domain: Association
range: Property
comment: subsets ownedEnd

RedefinableElement.redefinedElement
type: ObjectProperty
domain: RedefinableElement
range: RedefinableElement
comment: union

Expression.operand
type: ObjectProperty
domain: Expression
range: ValueSpecification
comment: ordered, subsets ownedElement

BehavioralFeature.ownedParameter
type: ObjectProperty
domain: BehavioralFeature
range: Parameter
comment: ordered, subsets ownedMember

Operation.redefinedOperation
type: ObjectProperty
domain: Operation
range: Operation
comment: subsets redefinedElement

Property.redefinedProperty
type: ObjectProperty
domain: Property
range: Property
comment: subsets redefinedElement

Operation.postcondition
type: ObjectProperty
domain: Operation
range: Constraint
comment: subsets ownedRule

Package.nestedPackage
type: ObjectProperty
domain: Package
range: Package
comment: subsets ownedMember

Package.nestingPackage
type: ObjectProperty
domain: Package
range: Package
comment: subsets namespace

RedefinableElement.redefinitionContext
type: ObjectProperty
domain: RedefinableElement
range: Classifier
comment: union

Association.memberEnd
type: ObjectProperty
domain: Association
range: Property
comment: ordered, subsets member

Namespace.member
type: ObjectProperty
domain: Namespace
range: NamedElement
comment: union

DirectedRelationship.target
type: ObjectProperty
domain: DirectedRelationship
range: Element
comment: union, subsets relatedElement

Package.ownedType
type: ObjectProperty
domain: Package
range: Type
comment: subsets ownedMember

Type.package
type: ObjectProperty
domain: Type
range: Package
comment: subsets namespace

Namespace.ownedMember
type: ObjectProperty
domain: Namespace
range: NamedElement
comment: union, subsets member, subsets ownedElement

NamedElement.namespace
type: ObjectProperty
domain: NamedElement
range: Namespace
comment: union, subsets owner

DirectedRelationship.source
type: ObjectProperty
domain: DirectedRelationship
range: Element
comment: union, subsets relatedElement

Classifier.attribute
type: ObjectProperty
domain: Classifier
range: Property
comment: subsets feature, union

Operation.precondition
type: ObjectProperty
domain: Operation
range: Constraint
comment: subsets ownedRule

Association.ownedEnd
type: ObjectProperty
domain: Association
range: Property
comment: ordered, subsets memberEnd, subsets feature, subsets ownedMember

Package.ownedMember
type: ObjectProperty
domain: Package
range: PackageableElement
comment: redefines ownedMember

Property.owningAssociation
type: ObjectProperty
domain: Property
range: Association
comment: subsets association, subsets namespace, subsets featuringClassifier

Class.ownedOperation
type: ObjectProperty
domain: Class
range: Operation
comment: ordered, subsets feature, subsets ownedMember

Operation.class
type: ObjectProperty
domain: Operation
range: Class
comment: subsets redefinitionContext, subsets namespace, subsets featuringClassifier

Namespace.packageImport
type: ObjectProperty
domain: Namespace
range: PackageImport
comment: subsets ownedElement

PackageImport.importingNamespace
type: ObjectProperty
type: FunctionalProperty
domain: PackageImport
range: Namespace
comment: subsets source, subsets owner

DataType.ownedOperation
type: ObjectProperty
domain: DataType
range: Operation
comment: ordered subsets feature, subsets ownedMember

Operation.datatype
type: ObjectProperty
domain: Operation
range: DataType
comment: subsets redefinitionContext, subsets namespace, subsets featuringClassifier

Namespace.elementImport
type: ObjectProperty
domain: Namespace
range: ElementImport
comment: subsets ownedElement

ElementImport.importingNamespace
type: ObjectProperty
type: FunctionalProperty
domain: ElementImport
range: Namespace
comment: subsets source, subsets owner

Relationship.relatedElement
type: ObjectProperty
domain: Relationship
range: Element
comment: union

Operation.bodyCondition
type: ObjectProperty
domain: Operation
range: Constraint
comment: subsets ownedRule

Constraint.specification
type: ObjectProperty
type: FunctionalProperty
domain: Constraint
range: ValueSpecification
comment: subsets ownedElement

Element.ownedComment
type: ObjectProperty
domain: Element
range: Comment
comment: subsets ownedElement

Constraint.constrainedElement
type: ObjectProperty
domain: Constraint
range: Element
comment: ordered

Class.ownedAttribute
type: ObjectProperty
domain: Class
range: Property
comment: ordered, subsets attribute, subsets ownedMember

Property.class
type: ObjectProperty
domain: Property
range: Class
comment: subsets namespace, subsets featuringClassifier, subsets classifier

DataType.ownedAttribute
type: ObjectProperty
domain: DataType
range: Property
comment: ordered subsets attribute, subsets ownedMember

Property.datatype
type: ObjectProperty
domain: Property
range: DataType
comment: subsets namespace, subsets featuringClassifier, subsets classifier

ElementImport.importedElement
type: ObjectProperty
type: FunctionalProperty
domain: ElementImport
range: PackageableElement
comment: subsets target

Enumeration.ownedLiteral
type: ObjectProperty
domain: Enumeration
range: EnumerationLiteral
comment: subsets ownedMember, ordered

EnumerationLiteral.enumeration
type: ObjectProperty
domain: EnumerationLiteral
range: Enumeration
comment: subsets namespace

PackageImport.importedPackage
type: ObjectProperty
type: FunctionalProperty
domain: PackageImport
range: Package
comment: subsets target

Association.endType
type: ObjectProperty
domain: Association
range: Type
comment: subsets relatedElement

Namespace.importedMember
type: ObjectProperty
domain: Namespace
range: PackageableElement
comment: subsets member

Class.superClass
type: ObjectProperty
domain: Class
range: Class
comment: redefines general