blob: b97f2e0cc6ece856bc71ee76888371fce1a79716 [file] [log] [blame]
-- @atlcompiler atl2006
-- ******************************************************************************
-- Copyright (c) 2006 INRIA.
-- All rights reserved. This program and the accompanying materials
-- are made available under the terms of the Eclipse Public License v2.0
-- which accompanies this distribution, and is available at
-- http://www.eclipse.org/legal/epl-v20.html
--
-- Contributors:
-- INRIA - Initial implementation
--
-- ******************************************************************************
-- $Id$
-- Copies UML2 models
module UML2Copy;
create OUT : UML2 from IN : UML2;
helper def : inElements : Set(UML2!"ecore::EObject") = UML2!"ecore::EObject"->allInstancesFrom('IN');
-- ======================================================================
-- UML2 copying rules begin
-- ======================================================================
-- Generated by: EModelCopyGenerator.atl 5428 2006-09-01 19:23:26Z dwagelaa
rule DurationInterval {
from s : UML2!"uml::DurationInterval" (thisModule.inElements->includes(s))
to t : UML2!"uml::DurationInterval" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type,
min <- s.min,
max <- s.max)
}
rule Deployment {
from s : UML2!"uml::Deployment" (thisModule.inElements->includes(s))
to t : UML2!"uml::Deployment" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
supplier <- s.supplier,
client <- s.client,
deployedArtifact <- s.deployedArtifact,
configuration <- s.configuration)
}
rule Slot {
from s : UML2!"uml::Slot" (thisModule.inElements->includes(s))
to t : UML2!"uml::Slot" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
definingFeature <- s.definingFeature,
value <- s.value)
}
rule DataStoreNode {
from s : UML2!"uml::DataStoreNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::DataStoreNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
ordering <- s.ordering,
isControlType <- s.isControlType,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
type <- s.type,
upperBound <- s.upperBound,
inState <- s.inState,
selection <- s.selection)
}
rule ReadIsClassifiedObjectAction {
from s : UML2!"uml::ReadIsClassifiedObjectAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ReadIsClassifiedObjectAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isDirect <- s.isDirect,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
classifier <- s.classifier,
result <- s.result,
object <- s.object)
}
rule Substitution {
from s : UML2!"uml::Substitution" (thisModule.inElements->includes(s))
to t : UML2!"uml::Substitution" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
supplier <- s.supplier,
client <- s.client,
mapping <- s.mapping,
contract <- s.contract)
}
rule Model {
from s : UML2!"uml::Model" (thisModule.inElements->includes(s))
to t : UML2!"uml::Model" mapsTo s (
name <- s.name->debug('Model'),
visibility <- s.visibility,
viewpoint <- s.viewpoint,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
packageMerge <- s.packageMerge,
packagedElement <- s.packagedElement,
profileApplication <- s.profileApplication)
}
rule AddStructuralFeatureValueAction {
from s : UML2!"uml::AddStructuralFeatureValueAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::AddStructuralFeatureValueAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isReplaceAll <- s.isReplaceAll,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
structuralFeature <- s.structuralFeature,
object <- s.object,
value <- s.value,
insertAt <- s.insertAt)
}
rule QualifierValue {
from s : UML2!"uml::QualifierValue" (thisModule.inElements->includes(s))
to t : UML2!"uml::QualifierValue" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
qualifier <- s.qualifier,
value <- s.value)
}
rule IntervalConstraint {
from s : UML2!"uml::IntervalConstraint" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::IntervalConstraint")
else false endif)
to t : UML2!"uml::IntervalConstraint" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
constrainedElement <- s.constrainedElement,
specification <- s.specification)
}
rule TimeObservation {
from s : UML2!"uml::TimeObservation" (thisModule.inElements->includes(s))
to t : UML2!"uml::TimeObservation" mapsTo s (
name <- s.name,
visibility <- s.visibility,
firstEvent <- s.firstEvent,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
event <- s.event)
}
rule InteractionUse {
from s : UML2!"uml::InteractionUse" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::InteractionUse")
else false endif)
to t : UML2!"uml::InteractionUse" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
refersTo <- s.refersTo,
actualGate <- s.actualGate,
argument <- s.argument)
}
rule ValueSpecificationAction {
from s : UML2!"uml::ValueSpecificationAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ValueSpecificationAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
value <- s.value,
result <- s.result)
}
rule ClassifierTemplateParameter {
from s : UML2!"uml::ClassifierTemplateParameter" (thisModule.inElements->includes(s))
to t : UML2!"uml::ClassifierTemplateParameter" mapsTo s (
allowSubstitutable <- s.allowSubstitutable,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
parameteredElement <- s.parameteredElement,
ownedParameteredElement <- s.ownedParameteredElement,
default <- s.default,
ownedDefault <- s.ownedDefault,
defaultClassifier <- s.defaultClassifier,
constrainingClassifier <- s.constrainingClassifier)
}
rule ReadLinkObjectEndQualifierAction {
from s : UML2!"uml::ReadLinkObjectEndQualifierAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ReadLinkObjectEndQualifierAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
object <- s.object,
result <- s.result,
qualifier <- s.qualifier)
}
rule LiteralInteger {
from s : UML2!"uml::LiteralInteger" (thisModule.inElements->includes(s))
to t : UML2!"uml::LiteralInteger" mapsTo s (
name <- s.name,
visibility <- s.visibility,
value <- s.value,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type)
}
rule ForkNode {
from s : UML2!"uml::ForkNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::ForkNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode)
}
rule Port {
from s : UML2!"uml::Port" (thisModule.inElements->includes(s))
to t : UML2!"uml::Port" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isStatic <- s.isStatic,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
isReadOnly <- s.isReadOnly,
isDerived <- s.isDerived,
isDerivedUnion <- s.isDerivedUnion,
aggregation <- s.aggregation,
isBehavior <- s.isBehavior,
isService <- s.isService,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
type <- s.type,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue,
templateParameter <- s.templateParameter,
end <- s.end,
deployment <- s.deployment,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
redefinedProperty <- s.redefinedProperty,
defaultValue <- s.defaultValue,
subsettedProperty <- s.subsettedProperty,
association <- s.association,
qualifier <- s.qualifier,
redefinedPort <- s.redefinedPort,
protocol <- s.protocol)
}
rule CallBehaviorAction {
from s : UML2!"uml::CallBehaviorAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::CallBehaviorAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isSynchronous <- s.isSynchronous,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
argument <- s.argument,
onPort <- s.onPort,
result <- s.result,
behavior <- s.behavior)
}
rule ReadLinkObjectEndAction {
from s : UML2!"uml::ReadLinkObjectEndAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ReadLinkObjectEndAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
object <- s.object,
end <- s.end,
result <- s.result)
}
rule StructuredActivityNode {
from s : UML2!"uml::StructuredActivityNode" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::StructuredActivityNode")
else false endif)
to t : UML2!"uml::StructuredActivityNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
mustIsolate <- s.mustIsolate,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
variable <- s.variable,
edge <- s.edge,
node <- s.node)
}
rule Parameter {
from s : UML2!"uml::Parameter" (thisModule.inElements->includes(s))
to t : UML2!"uml::Parameter" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
direction <- s.direction,
isException <- s.isException,
isStream <- s.isStream,
effect <- s.effect,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
type <- s.type,
templateParameter <- s.templateParameter,
end <- s.end,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue,
parameterSet <- s.parameterSet,
defaultValue <- s.defaultValue)
}
rule InterfaceRealization {
from s : UML2!"uml::InterfaceRealization" (thisModule.inElements->includes(s))
to t : UML2!"uml::InterfaceRealization" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
supplier <- s.supplier,
client <- s.client,
mapping <- s.mapping,
contract <- s.contract)
}
rule ConsiderIgnoreFragment {
from s : UML2!"uml::ConsiderIgnoreFragment" (thisModule.inElements->includes(s))
to t : UML2!"uml::ConsiderIgnoreFragment" mapsTo s (
name <- s.name,
visibility <- s.visibility,
interactionOperator <- s.interactionOperator,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
operand <- s.operand,
cfragmentGate <- s.cfragmentGate,
message <- s.message)
}
rule UnmarshallAction {
from s : UML2!"uml::UnmarshallAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::UnmarshallAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
result <- s.result,
unmarshallType <- s.unmarshallType,
object <- s.object)
}
rule StateInvariant {
from s : UML2!"uml::StateInvariant" (thisModule.inElements->includes(s))
to t : UML2!"uml::StateInvariant" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
invariant <- s.invariant)
}
rule OutputPin {
from s : UML2!"uml::OutputPin" (thisModule.inElements->includes(s))
to t : UML2!"uml::OutputPin" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
ordering <- s.ordering,
isControlType <- s.isControlType,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
isControl <- s.isControl,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
type <- s.type,
upperBound <- s.upperBound,
inState <- s.inState,
selection <- s.selection,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue)
}
rule CombinedFragment {
from s : UML2!"uml::CombinedFragment" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::CombinedFragment")
else false endif)
to t : UML2!"uml::CombinedFragment" mapsTo s (
name <- s.name,
visibility <- s.visibility,
interactionOperator <- s.interactionOperator,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
operand <- s.operand,
cfragmentGate <- s.cfragmentGate)
}
rule FinalState {
from s : UML2!"uml::FinalState" (thisModule.inElements->includes(s))
to t : UML2!"uml::FinalState" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
outgoing <- s.outgoing,
incoming <- s.incoming,
submachine <- s.submachine,
connection <- s.connection,
connectionPoint <- s.connectionPoint,
redefinedState <- s.redefinedState,
stateInvariant <- s.stateInvariant,
entry <- s.entry,
exit <- s.exit,
doActivity <- s.doActivity,
deferrableTrigger <- s.deferrableTrigger,
region <- s.region)
}
rule JoinNode {
from s : UML2!"uml::JoinNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::JoinNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isCombineDuplicate <- s.isCombineDuplicate,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
joinSpec <- s.joinSpec)
}
rule DecisionNode {
from s : UML2!"uml::DecisionNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::DecisionNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
decisionInput <- s.decisionInput)
}
rule OpaqueBehavior {
from s : UML2!"uml::OpaqueBehavior" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::OpaqueBehavior")
else false endif)
to t : UML2!"uml::OpaqueBehavior" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
isReentrant <- s.isReentrant,
body <- s.body,
language <- s.language,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception,
redefinedBehavior <- s.redefinedBehavior,
ownedParameter <- s.ownedParameter,
precondition <- s.precondition,
postcondition <- s.postcondition,
ownedParameterSet <- s.ownedParameterSet,
specification <- s.specification)
}
rule DataType {
from s : UML2!"uml::DataType" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::DataType")
else false endif)
to t : UML2!"uml::DataType" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedOperation <- s.ownedOperation)
}
rule ClearAssociationAction {
from s : UML2!"uml::ClearAssociationAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ClearAssociationAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
object <- s.object,
association <- s.association)
}
rule LinkEndDestructionData {
from s : UML2!"uml::LinkEndDestructionData" (thisModule.inElements->includes(s))
to t : UML2!"uml::LinkEndDestructionData" mapsTo s (
isDestroyDuplicates <- s.isDestroyDuplicates,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
value <- s.value,
end <- s.end,
qualifier <- s.qualifier,
destroyAt <- s.destroyAt)
}
rule AddVariableValueAction {
from s : UML2!"uml::AddVariableValueAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::AddVariableValueAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isReplaceAll <- s.isReplaceAll,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
variable <- s.variable,
value <- s.value,
insertAt <- s.insertAt)
}
rule Operation {
from s : UML2!"uml::Operation" (thisModule.inElements->includes(s))
to t : UML2!"uml::Operation" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isStatic <- s.isStatic,
isAbstract <- s.isAbstract,
concurrency <- s.concurrency,
isQuery <- s.isQuery,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
ownedParameter <- s.ownedParameter,
method <- s.method,
raisedException <- s.raisedException,
ownedParameterSet <- s.ownedParameterSet,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
precondition <- s.precondition,
postcondition <- s.postcondition,
redefinedOperation <- s.redefinedOperation,
bodyCondition <- s.bodyCondition)
}
rule LiteralString {
from s : UML2!"uml::LiteralString" (thisModule.inElements->includes(s))
to t : UML2!"uml::LiteralString" mapsTo s (
name <- s.name,
visibility <- s.visibility,
value <- s.value,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type)
}
rule ConditionalNode {
from s : UML2!"uml::ConditionalNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::ConditionalNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
mustIsolate <- s.mustIsolate,
isDeterminate <- s.isDeterminate,
isAssured <- s.isAssured,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
variable <- s.variable,
edge <- s.edge,
node <- s.node,
clause <- s.clause,
result <- s.result)
}
rule RedefinableTemplateSignature {
from s : UML2!"uml::RedefinableTemplateSignature" (thisModule.inElements->includes(s))
to t : UML2!"uml::RedefinableTemplateSignature" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
parameter <- s.parameter,
ownedParameter <- s.ownedParameter,
extendedSignature <- s.extendedSignature)
}
rule Class {
from s : UML2!"uml::Class" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Class")
else false endif)
to t : UML2!"uml::Class" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception)
}
rule AcceptEventAction {
from s : UML2!"uml::AcceptEventAction" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::AcceptEventAction")
else false endif)
to t : UML2!"uml::AcceptEventAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isUnmarshall <- s.isUnmarshall,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
result <- s.result,
trigger <- s.trigger)
}
rule InstanceSpecification {
from s : UML2!"uml::InstanceSpecification" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::InstanceSpecification")
else false endif)
to t : UML2!"uml::InstanceSpecification" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
deployment <- s.deployment,
templateParameter <- s.templateParameter,
classifier <- s.classifier,
slot <- s.slot,
specification <- s.specification)
}
rule Message {
from s : UML2!"uml::Message" (thisModule.inElements->includes(s))
to t : UML2!"uml::Message" mapsTo s (
name <- s.name,
visibility <- s.visibility,
messageSort <- s.messageSort,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
receiveEvent <- s.receiveEvent,
sendEvent <- s.sendEvent,
connector <- s.connector,
argument <- s.argument)
}
rule ClearVariableAction {
from s : UML2!"uml::ClearVariableAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ClearVariableAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
variable <- s.variable)
}
rule Actor {
from s : UML2!"uml::Actor" (thisModule.inElements->includes(s))
to t : UML2!"uml::Actor" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger)
}
rule ActivityFinalNode {
from s : UML2!"uml::ActivityFinalNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::ActivityFinalNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode)
}
rule Trigger {
from s : UML2!"uml::Trigger" (thisModule.inElements->includes(s))
to t : UML2!"uml::Trigger" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
event <- s.event,
port <- s.port)
}
rule FlowFinalNode {
from s : UML2!"uml::FlowFinalNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::FlowFinalNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode)
}
rule PackageImport {
from s : UML2!"uml::PackageImport" (thisModule.inElements->includes(s))
to t : UML2!"uml::PackageImport" mapsTo s (
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
importedPackage <- s.importedPackage)
}
rule Property {
from s : UML2!"uml::Property" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Property")
else false endif)
to t : UML2!"uml::Property" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isStatic <- s.isStatic,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
isReadOnly <- s.isReadOnly,
isDerived <- s.isDerived,
isDerivedUnion <- s.isDerivedUnion,
aggregation <- s.aggregation,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
type <- s.type,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue,
templateParameter <- s.templateParameter,
end <- s.end,
deployment <- s.deployment,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
redefinedProperty <- s.redefinedProperty,
defaultValue <- s.defaultValue,
subsettedProperty <- s.subsettedProperty,
association <- s.association,
qualifier <- s.qualifier)
}
rule ExtensionEnd {
from s : UML2!"uml::ExtensionEnd" (thisModule.inElements->includes(s))
to t : UML2!"uml::ExtensionEnd" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isStatic <- s.isStatic,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
isReadOnly <- s.isReadOnly,
isDerived <- s.isDerived,
isDerivedUnion <- s.isDerivedUnion,
aggregation <- s.aggregation,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
type <- s.type,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue,
templateParameter <- s.templateParameter,
end <- s.end,
deployment <- s.deployment,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
redefinedProperty <- s.redefinedProperty,
defaultValue <- s.defaultValue,
subsettedProperty <- s.subsettedProperty,
association <- s.association,
qualifier <- s.qualifier)
}
rule PrimitiveType {
from s : UML2!"uml::PrimitiveType" (thisModule.inElements->includes(s))
to t : UML2!"uml::PrimitiveType" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedOperation <- s.ownedOperation)
}
rule EAnnotation {
from s : UML2!"ecore::EAnnotation" (thisModule.inElements->includes(s))
to t : UML2!"ecore::EAnnotation" mapsTo s (
source <- s.source,
eAnnotations <- s.eAnnotations,
details <- s.details,
contents <- s.contents,
references <- s.references)
}
rule ProtocolTransition {
from s : UML2!"uml::ProtocolTransition" (thisModule.inElements->includes(s))
to t : UML2!"uml::ProtocolTransition" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
kind <- s.kind,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
target <- s.target,
redefinedTransition <- s.redefinedTransition,
guard <- s.guard,
effect <- s.effect,
trigger <- s.trigger,
source <- s.source,
postCondition <- s.postCondition,
preCondition <- s.preCondition)
}
rule Node {
from s : UML2!"uml::Node" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Node")
else false endif)
to t : UML2!"uml::Node" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception,
deployment <- s.deployment,
nestedNode <- s.nestedNode)
}
rule InformationFlow {
from s : UML2!"uml::InformationFlow" (thisModule.inElements->includes(s))
to t : UML2!"uml::InformationFlow" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
realization <- s.realization,
conveyed <- s.conveyed,
informationSource <- s.informationSource,
informationTarget <- s.informationTarget,
realizingActivityEdge <- s.realizingActivityEdge,
realizingConnector <- s.realizingConnector,
realizingMessage <- s.realizingMessage)
}
rule ProtocolStateMachine {
from s : UML2!"uml::ProtocolStateMachine" (thisModule.inElements->includes(s))
to t : UML2!"uml::ProtocolStateMachine" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
isReentrant <- s.isReentrant,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception,
redefinedBehavior <- s.redefinedBehavior,
ownedParameter <- s.ownedParameter,
precondition <- s.precondition,
postcondition <- s.postcondition,
ownedParameterSet <- s.ownedParameterSet,
specification <- s.specification,
region <- s.region,
submachineState <- s.submachineState,
connectionPoint <- s.connectionPoint,
extendedStateMachine <- s.extendedStateMachine,
conformance <- s.conformance)
}
rule BehaviorExecutionSpecification {
from s : UML2!"uml::BehaviorExecutionSpecification" (thisModule.inElements->includes(s))
to t : UML2!"uml::BehaviorExecutionSpecification" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
start <- s.start,
finish <- s.finish,
behavior <- s.behavior)
}
rule Include {
from s : UML2!"uml::Include" (thisModule.inElements->includes(s))
to t : UML2!"uml::Include" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
addition <- s.addition)
}
rule CallEvent {
from s : UML2!"uml::CallEvent" (thisModule.inElements->includes(s))
to t : UML2!"uml::CallEvent" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
operation <- s.operation)
}
rule AssociationClass {
from s : UML2!"uml::AssociationClass" (thisModule.inElements->includes(s))
to t : UML2!"uml::AssociationClass" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
isDerived <- s.isDerived,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception,
ownedEnd <- s.ownedEnd,
memberEnd <- s.memberEnd,
navigableOwnedEnd <- s.navigableOwnedEnd)
}
rule ElementImport {
from s : UML2!"uml::ElementImport" (thisModule.inElements->includes(s))
to t : UML2!"uml::ElementImport" mapsTo s (
visibility <- s.visibility,
alias <- s.alias,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
importedElement <- s.importedElement)
}
rule CallOperationAction {
from s : UML2!"uml::CallOperationAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::CallOperationAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isSynchronous <- s.isSynchronous,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
argument <- s.argument,
onPort <- s.onPort,
result <- s.result,
operation <- s.operation,
target <- s.target)
}
rule MergeNode {
from s : UML2!"uml::MergeNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::MergeNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode)
}
rule ActionExecutionSpecification {
from s : UML2!"uml::ActionExecutionSpecification" (thisModule.inElements->includes(s))
to t : UML2!"uml::ActionExecutionSpecification" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
start <- s.start,
finish <- s.finish,
action <- s.action)
}
rule Manifestation {
from s : UML2!"uml::Manifestation" (thisModule.inElements->includes(s))
to t : UML2!"uml::Manifestation" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
supplier <- s.supplier,
client <- s.client,
mapping <- s.mapping,
utilizedElement <- s.utilizedElement)
}
rule Pin {
from s : UML2!"uml::Pin" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Pin")
else false endif)
to t : UML2!"uml::Pin" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
ordering <- s.ordering,
isControlType <- s.isControlType,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
isControl <- s.isControl,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
type <- s.type,
upperBound <- s.upperBound,
inState <- s.inState,
selection <- s.selection,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue)
}
rule CentralBufferNode {
from s : UML2!"uml::CentralBufferNode" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::CentralBufferNode")
else false endif)
to t : UML2!"uml::CentralBufferNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
ordering <- s.ordering,
isControlType <- s.isControlType,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
type <- s.type,
upperBound <- s.upperBound,
inState <- s.inState,
selection <- s.selection)
}
rule EStringToStringMapEntry {
from s : UML2!"ecore::EStringToStringMapEntry" (thisModule.inElements->includes(s))
to t : UML2!"ecore::EStringToStringMapEntry" mapsTo s (
key <- s.key,
value <- s.value)
}
rule DestructionEvent {
from s : UML2!"uml::DestructionEvent" (thisModule.inElements->includes(s))
to t : UML2!"uml::DestructionEvent" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter)
}
rule Package {
from s : UML2!"uml::Package" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Package")
else false endif)
to t : UML2!"uml::Package" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
packageMerge <- s.packageMerge,
packagedElement <- s.packagedElement,
profileApplication <- s.profileApplication)
}
rule ProtocolConformance {
from s : UML2!"uml::ProtocolConformance" (thisModule.inElements->includes(s))
to t : UML2!"uml::ProtocolConformance" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
generalMachine <- s.generalMachine)
}
rule Signal {
from s : UML2!"uml::Signal" (thisModule.inElements->includes(s))
to t : UML2!"uml::Signal" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute)
}
rule RaiseExceptionAction {
from s : UML2!"uml::RaiseExceptionAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::RaiseExceptionAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
exception <- s.exception)
}
rule TimeExpression {
from s : UML2!"uml::TimeExpression" (thisModule.inElements->includes(s))
to t : UML2!"uml::TimeExpression" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type,
expr <- s.expr,
observation <- s.observation)
}
rule ConnectableElementTemplateParameter {
from s : UML2!"uml::ConnectableElementTemplateParameter" (thisModule.inElements->includes(s))
to t : UML2!"uml::ConnectableElementTemplateParameter" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
parameteredElement <- s.parameteredElement,
ownedParameteredElement <- s.ownedParameteredElement,
default <- s.default,
ownedDefault <- s.ownedDefault)
}
rule LoopNode {
from s : UML2!"uml::LoopNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::LoopNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
mustIsolate <- s.mustIsolate,
isTestedFirst <- s.isTestedFirst,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
variable <- s.variable,
edge <- s.edge,
node <- s.node,
bodyPart <- s.bodyPart,
setupPart <- s.setupPart,
decider <- s.decider,
test <- s.test,
result <- s.result,
loopVariable <- s.loopVariable,
bodyOutput <- s.bodyOutput,
loopVariableInput <- s.loopVariableInput)
}
rule TemplateParameter {
from s : UML2!"uml::TemplateParameter" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::TemplateParameter")
else false endif)
to t : UML2!"uml::TemplateParameter" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
parameteredElement <- s.parameteredElement,
ownedParameteredElement <- s.ownedParameteredElement,
default <- s.default,
ownedDefault <- s.ownedDefault)
}
rule RemoveVariableValueAction {
from s : UML2!"uml::RemoveVariableValueAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::RemoveVariableValueAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isRemoveDuplicates <- s.isRemoveDuplicates,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
variable <- s.variable,
value <- s.value,
removeAt <- s.removeAt)
}
rule Usage {
from s : UML2!"uml::Usage" (thisModule.inElements->includes(s))
to t : UML2!"uml::Usage" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
supplier <- s.supplier,
client <- s.client)
}
rule Image {
from s : UML2!"uml::Image" (thisModule.inElements->includes(s))
to t : UML2!"uml::Image" mapsTo s (
content <- s.content,
location <- s.location,
format <- s.format,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment)
}
rule SendSignalEvent {
from s : UML2!"uml::SendSignalEvent" (thisModule.inElements->includes(s))
to t : UML2!"uml::SendSignalEvent" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
signal <- s.signal)
}
rule LinkEndData {
from s : UML2!"uml::LinkEndData" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::LinkEndData")
else false endif)
to t : UML2!"uml::LinkEndData" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
value <- s.value,
end <- s.end,
qualifier <- s.qualifier)
}
rule LiteralUnlimitedNatural {
from s : UML2!"uml::LiteralUnlimitedNatural" (thisModule.inElements->includes(s))
to t : UML2!"uml::LiteralUnlimitedNatural" mapsTo s (
name <- s.name,
visibility <- s.visibility,
value <- s.value,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type)
}
rule ExpansionNode {
from s : UML2!"uml::ExpansionNode" (thisModule.inElements->includes(s))
to t : UML2!"uml::ExpansionNode" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
ordering <- s.ordering,
isControlType <- s.isControlType,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
type <- s.type,
upperBound <- s.upperBound,
inState <- s.inState,
selection <- s.selection,
regionAsOutput <- s.regionAsOutput,
regionAsInput <- s.regionAsInput)
}
rule TemplateSignature {
from s : UML2!"uml::TemplateSignature" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::TemplateSignature")
else false endif)
to t : UML2!"uml::TemplateSignature" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
parameter <- s.parameter,
ownedParameter <- s.ownedParameter)
}
rule InputPin {
from s : UML2!"uml::InputPin" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::InputPin")
else false endif)
to t : UML2!"uml::InputPin" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
ordering <- s.ordering,
isControlType <- s.isControlType,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
isControl <- s.isControl,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
type <- s.type,
upperBound <- s.upperBound,
inState <- s.inState,
selection <- s.selection,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue)
}
rule Variable {
from s : UML2!"uml::Variable" (thisModule.inElements->includes(s))
to t : UML2!"uml::Variable" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isOrdered <- s.isOrdered,
isUnique <- s.isUnique,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
type <- s.type,
templateParameter <- s.templateParameter,
end <- s.end,
upperValue <- s.upperValue,
lowerValue <- s.lowerValue)
}
rule DestroyLinkAction {
from s : UML2!"uml::DestroyLinkAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::DestroyLinkAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
endData <- s.endData,
inputValue <- s.inputValue)
}
rule Duration {
from s : UML2!"uml::Duration" (thisModule.inElements->includes(s))
to t : UML2!"uml::Duration" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type,
expr <- s.expr,
observation <- s.observation)
}
rule Comment {
from s : UML2!"uml::Comment" (thisModule.inElements->includes(s))
to t : UML2!"uml::Comment" mapsTo s (
body <- s.body,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
annotatedElement <- s.annotatedElement)
}
rule Continuation {
from s : UML2!"uml::Continuation" (thisModule.inElements->includes(s))
to t : UML2!"uml::Continuation" mapsTo s (
name <- s.name,
visibility <- s.visibility,
setting <- s.setting,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering)
}
rule Component {
from s : UML2!"uml::Component" (thisModule.inElements->includes(s))
to t : UML2!"uml::Component" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
isIndirectlyInstantiated <- s.isIndirectlyInstantiated,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception,
packagedElement <- s.packagedElement,
realization <- s.realization)
}
rule GeneralOrdering {
from s : UML2!"uml::GeneralOrdering" (thisModule.inElements->includes(s))
to t : UML2!"uml::GeneralOrdering" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
before <- s.before,
after <- s.after)
}
rule OpaqueExpression {
from s : UML2!"uml::OpaqueExpression" (thisModule.inElements->includes(s))
to t : UML2!"uml::OpaqueExpression" mapsTo s (
name <- s.name,
visibility <- s.visibility,
body <- s.body,
language <- s.language,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type,
behavior <- s.behavior)
}
rule BroadcastSignalAction {
from s : UML2!"uml::BroadcastSignalAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::BroadcastSignalAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
argument <- s.argument,
onPort <- s.onPort,
signal <- s.signal)
}
rule ExtensionPoint {
from s : UML2!"uml::ExtensionPoint" (thisModule.inElements->includes(s))
to t : UML2!"uml::ExtensionPoint" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression)
}
rule CollaborationUse {
from s : UML2!"uml::CollaborationUse" (thisModule.inElements->includes(s))
to t : UML2!"uml::CollaborationUse" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
type <- s.type,
roleBinding <- s.roleBinding)
}
rule ReplyAction {
from s : UML2!"uml::ReplyAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ReplyAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
replyToCall <- s.replyToCall,
returnInformation <- s.returnInformation,
replyValue <- s.replyValue)
}
rule ChangeEvent {
from s : UML2!"uml::ChangeEvent" (thisModule.inElements->includes(s))
to t : UML2!"uml::ChangeEvent" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
changeExpression <- s.changeExpression)
}
rule ActivityPartition {
from s : UML2!"uml::ActivityPartition" (thisModule.inElements->includes(s))
to t : UML2!"uml::ActivityPartition" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isDimension <- s.isDimension,
isExternal <- s.isExternal,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
node <- s.node,
subpartition <- s.subpartition,
represents <- s.represents,
edge <- s.edge)
}
rule ExecutionOccurrenceSpecification {
from s : UML2!"uml::ExecutionOccurrenceSpecification" (thisModule.inElements->includes(s))
to t : UML2!"uml::ExecutionOccurrenceSpecification" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
toBefore <- s.toBefore,
event <- s.event,
toAfter <- s.toAfter,
execution <- s.execution)
}
rule OccurrenceSpecification {
from s : UML2!"uml::OccurrenceSpecification" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::OccurrenceSpecification")
else false endif)
to t : UML2!"uml::OccurrenceSpecification" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
covered <- s.covered,
generalOrdering <- s.generalOrdering,
toBefore <- s.toBefore,
event <- s.event,
toAfter <- s.toAfter)
}
rule Realization {
from s : UML2!"uml::Realization" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Realization")
else false endif)
to t : UML2!"uml::Realization" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
supplier <- s.supplier,
client <- s.client,
mapping <- s.mapping)
}
rule SendObjectAction {
from s : UML2!"uml::SendObjectAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::SendObjectAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
argument <- s.argument,
onPort <- s.onPort,
target <- s.target,
request <- s.request)
}
rule Collaboration {
from s : UML2!"uml::Collaboration" (thisModule.inElements->includes(s))
to t : UML2!"uml::Collaboration" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
collaborationRole <- s.collaborationRole)
}
rule Transition {
from s : UML2!"uml::Transition" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::Transition")
else false endif)
to t : UML2!"uml::Transition" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
kind <- s.kind,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
target <- s.target,
redefinedTransition <- s.redefinedTransition,
guard <- s.guard,
effect <- s.effect,
trigger <- s.trigger,
source <- s.source)
}
rule ControlFlow {
from s : UML2!"uml::ControlFlow" (thisModule.inElements->includes(s))
to t : UML2!"uml::ControlFlow" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
source <- s.source,
target <- s.target,
redefinedEdge <- s.redefinedEdge,
inPartition <- s.inPartition,
guard <- s.guard,
weight <- s.weight,
interrupts <- s.interrupts)
}
rule TimeConstraint {
from s : UML2!"uml::TimeConstraint" (thisModule.inElements->includes(s))
to t : UML2!"uml::TimeConstraint" mapsTo s (
name <- s.name,
visibility <- s.visibility,
firstEvent <- s.firstEvent,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
constrainedElement <- s.constrainedElement,
specification <- s.specification)
}
rule DurationConstraint {
from s : UML2!"uml::DurationConstraint" (thisModule.inElements->includes(s))
to t : UML2!"uml::DurationConstraint" mapsTo s (
name <- s.name,
visibility <- s.visibility,
firstEvent <- s.firstEvent,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
constrainedElement <- s.constrainedElement,
specification <- s.specification)
}
rule TestIdentityAction {
from s : UML2!"uml::TestIdentityAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::TestIdentityAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
first <- s.first,
second <- s.second,
result <- s.result)
}
rule ReduceAction {
from s : UML2!"uml::ReduceAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::ReduceAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isOrdered <- s.isOrdered,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
reducer <- s.reducer,
result <- s.result,
collection <- s.collection)
}
rule ConnectionPointReference {
from s : UML2!"uml::ConnectionPointReference" (thisModule.inElements->includes(s))
to t : UML2!"uml::ConnectionPointReference" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
entry <- s.entry,
exit <- s.exit)
}
rule GeneralizationSet {
from s : UML2!"uml::GeneralizationSet" (thisModule.inElements->includes(s))
to t : UML2!"uml::GeneralizationSet" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isCovering <- s.isCovering,
isDisjoint <- s.isDisjoint,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
powertype <- s.powertype,
generalization <- s.generalization)
}
rule TemplateParameterSubstitution {
from s : UML2!"uml::TemplateParameterSubstitution" (thisModule.inElements->includes(s))
to t : UML2!"uml::TemplateParameterSubstitution" mapsTo s (
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
formal <- s.formal,
actual <- s.actual,
ownedActual <- s.ownedActual)
}
rule StateMachine {
from s : UML2!"uml::StateMachine" (
if thisModule.inElements->includes(s) then
s->oclIsTypeOf(UML2!"uml::StateMachine")
else false endif)
to t : UML2!"uml::StateMachine" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
isAbstract <- s.isAbstract,
isActive <- s.isActive,
isReentrant <- s.isReentrant,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
elementImport <- s.elementImport,
packageImport <- s.packageImport,
ownedRule <- s.ownedRule,
templateParameter <- s.templateParameter,
templateBinding <- s.templateBinding,
ownedTemplateSignature <- s.ownedTemplateSignature,
generalization <- s.generalization,
powertypeExtent <- s.powertypeExtent,
redefinedClassifier <- s.redefinedClassifier,
substitution <- s.substitution,
representation <- s.representation,
collaborationUse <- s.collaborationUse,
ownedUseCase <- s.ownedUseCase,
useCase <- s.useCase,
ownedAttribute <- s.ownedAttribute,
ownedConnector <- s.ownedConnector,
ownedBehavior <- s.ownedBehavior,
classifierBehavior <- s.classifierBehavior,
interfaceRealization <- s.interfaceRealization,
ownedTrigger <- s.ownedTrigger,
nestedClassifier <- s.nestedClassifier,
ownedOperation <- s.ownedOperation,
ownedReception <- s.ownedReception,
redefinedBehavior <- s.redefinedBehavior,
ownedParameter <- s.ownedParameter,
precondition <- s.precondition,
postcondition <- s.postcondition,
ownedParameterSet <- s.ownedParameterSet,
specification <- s.specification,
region <- s.region,
submachineState <- s.submachineState,
connectionPoint <- s.connectionPoint,
extendedStateMachine <- s.extendedStateMachine)
}
rule TimeInterval {
from s : UML2!"uml::TimeInterval" (thisModule.inElements->includes(s))
to t : UML2!"uml::TimeInterval" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
type <- s.type,
min <- s.min,
max <- s.max)
}
rule Lifeline {
from s : UML2!"uml::Lifeline" (thisModule.inElements->includes(s))
to t : UML2!"uml::Lifeline" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
represents <- s.represents,
selector <- s.selector,
decomposedAs <- s.decomposedAs,
coveredBy <- s.coveredBy)
}
rule SendSignalAction {
from s : UML2!"uml::SendSignalAction" (thisModule.inElements->includes(s))
to t : UML2!"uml::SendSignalAction" mapsTo s (
name <- s.name,
visibility <- s.visibility,
isLeaf <- s.isLeaf,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
outgoing <- s.outgoing,
incoming <- s.incoming,
inPartition <- s.inPartition,
inInterruptibleRegion <- s.inInterruptibleRegion,
redefinedNode <- s.redefinedNode,
handler <- s.handler,
localPrecondition <- s.localPrecondition,
localPostcondition <- s.localPostcondition,
argument <- s.argument,
onPort <- s.onPort,
target <- s.target,
signal <- s.signal)
}
rule SignalEvent {
from s : UML2!"uml::SignalEvent" (thisModule.inElements->includes(s))
to t : UML2!"uml::SignalEvent" mapsTo s (
name <- s.name,
visibility <- s.visibility,
eAnnotations <- s.eAnnotations,
ownedComment <- s.ownedComment,
clientDependency <- s.clientDependency,
nameExpression <- s.nameExpression,
templateParameter <- s.templateParameter,
signal <- s.signal)
}
rule EnumerationLiteral {
from s : UML2!"uml::EnumerationLiteral" (thisModule.inElements->includes(s))
to t : UML2!"uml::EnumerationLiteral" mapsTo s (