-- $Id$
module ModelMerge;

create OUT : OUTMODEL from IN : INMODEL, MERGE : MERGEMODEL;

-- ======================================================================
-- model-specific helpers begin
-- ======================================================================

helper context INMODEL!ModelElement def : isInPackage() : Boolean =
	not INMODEL!Package.allInstances()->select(p|
		p=self.namespace and p.oclIsTypeOf(INMODEL!Package))->isEmpty();

helper context INMODEL!ModelElement def : qName() : String =
	if self.isInPackage() then
		self.namespace.qName() + '.' + self.name
	else
		self.name
	endif;

helper context MERGEMODEL!ModelElement def : isInPackage() : Boolean =
	not MERGEMODEL!Package.allInstances()->select(p|
		p=self.namespace and p.oclIsTypeOf(MERGEMODEL!Package))->isEmpty();

helper context MERGEMODEL!ModelElement def : qName() : String =
	if self.isInPackage() then
		self.namespace.qName() + '.' + self.name
	else
		self.name
	endif;

helper context MERGEMODEL!Model def : notInSourceModel() : Boolean =
	false;

helper context MERGEMODEL!Model def : fromSourceModel() : INMODEL!Model =
	INMODEL!Model.allInstances()->asSequence()->first();

helper context MERGEMODEL!Classifier def : notInSourceModel() : Boolean =
	INMODEL!Classifier.allInstances()->select(e|e.qName()=self.qName())->isEmpty();

helper context MERGEMODEL!Classifier def : fromSourceModel() : INMODEL!Classifier =
	INMODEL!Classifier.allInstances()->select(e|e.qName()=self.qName())->first();

helper context MERGEMODEL!Package def : notInSourceModel() : Boolean =
	INMODEL!Package.allInstances()->select(e|e.qName()=self.qName())->isEmpty();

helper context MERGEMODEL!Package def : fromSourceModel() : INMODEL!Package =
	INMODEL!Package.allInstances()->select(e|e.qName()=self.qName())->first();

helper context MERGEMODEL!TagDefinition def : notInSourceModel() : Boolean =
	INMODEL!TagDefinition.allInstances()->select(e|e.qName()=self.qName())->isEmpty();

helper context MERGEMODEL!TagDefinition def : fromSourceModel() : INMODEL!TagDefinition =
	INMODEL!TagDefinition.allInstances()->select(e|e.qName()=self.qName())->first();

helper context MERGEMODEL!Stereotype def : notInSourceModel() : Boolean =
	INMODEL!Stereotype.allInstances()->select(e|e.qName()=self.qName())->isEmpty();

helper context MERGEMODEL!Stereotype def : fromSourceModel() : INMODEL!Stereotype =
	INMODEL!Stereotype.allInstances()->select(e|e.qName()=self.qName())->first();

helper context MERGEMODEL!Association def : notInSourceModel() : Boolean =
	not self.connection->forAll(c|c.inSourceModel());

helper context MERGEMODEL!AssociationEnd def : inSourceModel() : Boolean =
	if self.isNavigable then
		not INMODEL!AssociationEnd.allInstances()->select(e|e.isNavigable)->select(e|
			e.name=self.name and e.participant.qName()=self.participant.qName())->isEmpty()
	else if self.otherEnd().isNavigable then
		self.otherEnd().inSourceModel()
	else
		true
	endif endif;

helper context MERGEMODEL!AssociationEnd def : notInSourceModel() : Boolean =
	self.association.notInSourceModel();

helper context MERGEMODEL!AssociationEnd def : otherEnd() : MERGEMODEL!AssociationEnd =
	self.association.connection->select(x|x<>self)->first();

helper context MERGEMODEL!TaggedValue def : notInSourceModel() : Boolean =
	self.modelElement.notInSourceModel();

helper context MERGEMODEL!StructuralFeature def : notInSourceModel() : Boolean =
	if self.owner.notInSourceModel() then
		true
	else
		self.owner.fromSourceModel().feature->select(f|
			f.name=self.name and f.oclIsKindOf(INMODEL!StructuralFeature))
	endif;

helper context MERGEMODEL!Operation def : notInSourceModel() : Boolean =
	if self.owner.notInSourceModel() then
		true
	else
		self.owner.fromSourceModel().feature->select(f|
			f.name=self.name and f.oclIsKindOf(INMODEL!Operation))->select(o|
				o.hasSameParametersAs(self))->isEmpty()
	endif;

helper context INMODEL!BehavioralFeature def : hasSameParametersAs(f : MERGEMODEL!BehavioralFeature) : Boolean =
	f.parameter->select(p|not self.hasSameParameter(p))->isEmpty();
	
helper context INMODEL!BehavioralFeature def : hasSameParameter(p : MERGEMODEL!Parameter) : Boolean =
	not self.parameter->select(sp|sp.kind=p.kind and sp.type.qName()=p.type.qName())->isEmpty();

helper context MERGEMODEL!Method def : notInSourceModel() : Boolean =
	if self.owner.notInSourceModel() then
		true
	else
		self.specification.notInSourceModel()
	endif;

helper context MERGEMODEL!Expression def : notInSourceModel() : Boolean =
	if not MERGEMODEL!Attribute.allInstances()->select(a|a.initialValue=self)->isEmpty() then
		MERGEMODEL!Attribute.allInstances()->select(a|a.initialValue=self)->first().notInSourceModel()
	else if	not MERGEMODEL!Method.allInstances()->select(m|m.body=self)->isEmpty() then
		MERGEMODEL!Method.allInstances()->select(m|m.body=self)->first().notInSourceModel()
	else
		false
	endif endif;

helper context MERGEMODEL!Dependency def : notInSourceModel() : Boolean =
	INMODEL!Dependency.allInstances()->select(d|
		d.supplier->forAll(s1|self.supplier->forAll(s2|s1.qName()=s2.qName())) and
		d.client->forAll(c1|self.client->forAll(c2|c1.qName()=c2.qName())))->isEmpty();

helper context MERGEMODEL!Generalization def : notInSourceModel() : Boolean =
	INMODEL!Generalization.allInstances()->select(g|
		g.parent.qName()=self.parent.qName() and
		g.child.qName()=self.child.qName())->isEmpty();

helper context MERGEMODEL!Multiplicity def : notInSourceModel() : Boolean =
	if not MERGEMODEL!StructuralFeature.allInstances()->select(e|e.multiplicity=self)->isEmpty() then
		MERGEMODEL!StructuralFeature.allInstances()->select(e|e.multiplicity=self)->first().notInSourceModel()
	else if	not MERGEMODEL!AssociationEnd.allInstances()->select(e|e.multiplicity=self)->isEmpty() then
		MERGEMODEL!AssociationEnd.allInstances()->select(e|e.multiplicity=self)->first().notInSourceModel()
	else if	not MERGEMODEL!TagDefinition.allInstances()->select(e|e.multiplicity=self)->isEmpty() then
		MERGEMODEL!TagDefinition.allInstances()->select(e|e.multiplicity=self)->first().notInSourceModel()
	else
		false
	endif endif endif;

helper context MERGEMODEL!MultiplicityRange def : notInSourceModel() : Boolean =
	self.multiplicity.notInSourceModel();

helper context MERGEMODEL!Parameter def : notInSourceModel() : Boolean =
	if self.behavioralFeature.oclIsUndefined() then
		not MERGEMODEL!Event.allInstances()->select(e|
			e.parameter->includes(self) and e.notInSourceModel())->isEmpty()
	else
		self.behavioralFeature.notInSourceModel()
	endif;

helper context MERGEMODEL!Event def : notInSourceModel() : Boolean =
	not MERGEMODEL!Transition.allInstances()->select(t|
		t.trigger=self and t.notInSourceModel())->isEmpty();

helper context MERGEMODEL!Action def : notInSourceModel() : Boolean =
	not MERGEMODEL!Transition.allInstances()->select(t|
		t.effect=self and t.notInSourceModel())->isEmpty();

helper context MERGEMODEL!Guard def : notInSourceModel() : Boolean =
	self.transition.notInSourceModel();

helper context MERGEMODEL!Transition def : notInSourceModel() : Boolean =
	self.source.notInSourceModel() or self.target.notInSourceModel();

helper context MERGEMODEL!StateVertex def : svNotInSourceModel() : Boolean =
	if self.container.notInSourceModel() then
		true
	else
		self.container.fromSourceModel().subvertex->select(v|
			v.name=self.name)->isEmpty()
	endif;

helper context MERGEMODEL!StateVertex def : notInSourceModel() : Boolean =
	self.svNotInSourceModel();

helper context MERGEMODEL!StateVertex def : svFromSourceModel() : INMODEL!StateVertex =
	self.container.fromSourceModel().subvertex->select(v|
		v.name=self.name)->first();

helper context MERGEMODEL!StateVertex def : fromSourceModel() : INMODEL!StateVertex =
	self.svFromSourceModel();

helper context MERGEMODEL!State def : notInSourceModel() : Boolean =
	if self.container.oclIsUndefined() then
		self.stateMachine.notInSourceModel()
	else
		self.svNotInSourceModel()
	endif;

helper context MERGEMODEL!State def : fromSourceModel() : INMODEL!State =
	if self.container.oclIsUndefined() then
		self.stateMachine.fromSourceModel().top
	else
		self.svFromSourceModel()
	endif;

helper context MERGEMODEL!StateMachine def : notInSourceModel() : Boolean =
	if self."context".notInSourceModel() then
		true
	else
		self."context".fromSourceModel().behavior->isEmpty()
	endif;

helper context MERGEMODEL!StateMachine def : fromSourceModel() : INMODEL!StateMachine =
	self."context".fromSourceModel().behavior->asSequence()->first();

-- ======================================================================
-- model-specific helpers end
-- ======================================================================

-- ======================================================================
-- model merge begin
-- ======================================================================

rule MergeAssociation {
    from s : MERGEMODEL!Association (s.oclIsTypeOf(MERGEMODEL!Association) and
    	s.notInSourceModel())
    to t : OUTMODEL!Association mapsTo s (
        isRoot <- s.isRoot,
        isAbstract <- s.isAbstract,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        generalization <- s.generalization,
        comment <- s.comment,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        connection <- s.connection,
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeTaggedValue {
    from s : MERGEMODEL!TaggedValue (s.notInSourceModel())
    to t : OUTMODEL!TaggedValue mapsTo s (
        dataValue <- s.dataValue,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        referenceValue <- s.referenceValue,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
        type <- if s.type.notInSourceModel()
			then s.type
			else s.type.fromSourceModel() endif)
}

rule MergeOperation {
    from s : MERGEMODEL!Operation (s.notInSourceModel())
    to t : OUTMODEL!Operation mapsTo s (
        ownerScope <- s.ownerScope,
        visibility <- s.visibility,
        isQuery <- s.isQuery,
        isAbstract <- s.isAbstract,
        concurrency <- s.concurrency,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isRoot <- s.isRoot,
        isLeaf <- s.isLeaf,
        specification <- s.specification,
        templateParameter <- s.templateParameter,
        parameter <- s.parameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow)
}

rule MergeProcedureExpression {
    from s : MERGEMODEL!ProcedureExpression (s.notInSourceModel())
    to t : OUTMODEL!ProcedureExpression mapsTo s (
        language <- s.language,
        body <- s.body)
}

rule MergeAbstraction {
    from s : MERGEMODEL!Abstraction (s.notInSourceModel())
    to t : OUTMODEL!Abstraction mapsTo s (
        mapping <- s.mapping,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        client <- s.client->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        supplier <- s.supplier->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeMultiplicity {
    from s : MERGEMODEL!Multiplicity (s.notInSourceModel())
    to t : OUTMODEL!Multiplicity mapsTo s (
        range <- s.range)
}

rule MergeParameter {
    from s : MERGEMODEL!Parameter (s.notInSourceModel())
    to t : OUTMODEL!Parameter mapsTo s (
        kind <- s.kind,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        defaultValue <- s.defaultValue,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        type <- if s.type.notInSourceModel()
			then s.type
			else s.type.fromSourceModel() endif,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow)
}

rule MergeClass {
    from s : MERGEMODEL!Class (s.oclIsTypeOf(MERGEMODEL!Class) and
    	s.notInSourceModel())
    to t : OUTMODEL!Class mapsTo s (
        isRoot <- s.isRoot,
        isActive <- s.isActive,
        isAbstract <- s.isAbstract,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        generalization <- s.generalization,
        comment <- s.comment,
        powertypeRange <- s.powertypeRange,
        feature <- s.feature,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeInterface {
    from s : MERGEMODEL!Interface (s.notInSourceModel())
    to t : OUTMODEL!Interface mapsTo s (
        isRoot <- s.isRoot,
        isAbstract <- s.isAbstract,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        generalization <- s.generalization,
        comment <- s.comment,
        powertypeRange <- s.powertypeRange,
        feature <- s.feature,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeMultiplicityRange {
    from s : MERGEMODEL!MultiplicityRange (s.notInSourceModel())
    to t : OUTMODEL!MultiplicityRange mapsTo s (
        upper <- s.upper,
        lower <- s.lower)
}

rule MergeExpression {
    from s : MERGEMODEL!Expression (s.oclIsTypeOf(MERGEMODEL!Expression) and
    	s.notInSourceModel())
    to t : OUTMODEL!Expression mapsTo s (
        language <- s.language,
        body <- s.body)
}

rule MergeDataType {
    from s : MERGEMODEL!DataType (s.oclIsTypeOf(MERGEMODEL!DataType) and
    	s.notInSourceModel())
    to t : OUTMODEL!DataType mapsTo s (
        isRoot <- s.isRoot,
        isAbstract <- s.isAbstract,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        generalization <- s.generalization,
        comment <- s.comment,
        powertypeRange <- s.powertypeRange,
        feature <- s.feature,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergePackage {
    from s : MERGEMODEL!Package (s.oclIsTypeOf(MERGEMODEL!Package) and
    	s.notInSourceModel())
    to t : OUTMODEL!Package mapsTo s (
        isRoot <- s.isRoot,
        isAbstract <- s.isAbstract,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        generalization <- s.generalization,
        comment <- s.comment,
        elementImport <- s.elementImport,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeAssociationEnd {
    from s : MERGEMODEL!AssociationEnd (s.oclIsTypeOf(MERGEMODEL!AssociationEnd) and
    	s.notInSourceModel())
    to t : OUTMODEL!AssociationEnd mapsTo s (
        targetScope <- s.targetScope,
        isNavigable <- s.isNavigable,
        ordering <- s.ordering,
        changeability <- s.changeability,
        multiplicity <- s.multiplicity,
        aggregation <- s.aggregation,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        qualifier <- s.qualifier,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        participant <- if s.participant.notInSourceModel()
			then s.participant
			else s.participant.fromSourceModel() endif,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        constraint <- s.constraint,
        specification <- s.specification,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow)
}

rule MergeAttribute {
    from s : MERGEMODEL!Attribute (s.notInSourceModel())
    to t : OUTMODEL!Attribute mapsTo s (
        targetScope <- s.targetScope,
        initialValue <- s.initialValue,
        ownerScope <- s.ownerScope,
        visibility <- s.visibility,
        changeability <- s.changeability,
        ordering <- s.ordering,
        name <- s.name,
        isSpecification <- s.isSpecification,
        multiplicity <- s.multiplicity,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        type <- if s.type.notInSourceModel()
			then s.type
			else s.type.fromSourceModel() endif,
        sourceFlow <- s.sourceFlow)
}

rule MergeGeneralization {
    from s : MERGEMODEL!Generalization (s.notInSourceModel())
    to t : OUTMODEL!Generalization mapsTo s (
        discriminator <- s.discriminator,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        powertype <- s.powertype,
        parent <- if s.parent.notInSourceModel()
			then s.parent
			else s.parent.fromSourceModel() endif,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        child <- if s.child.notInSourceModel()
			then s.child
			else s.child.fromSourceModel() endif,
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeDependency {
    from s : MERGEMODEL!Dependency (s.oclIsTypeOf(MERGEMODEL!Dependency) and
    	s.notInSourceModel())
    to t : OUTMODEL!Dependency mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        client <- s.client->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        supplier <- s.supplier->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeTagDefinition {
    from s : MERGEMODEL!TagDefinition (s.notInSourceModel())
    to t : OUTMODEL!TagDefinition mapsTo s (
        tagType <- s.tagType,
        multiplicity <- s.multiplicity,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeStereotype {
    from s : MERGEMODEL!Stereotype (s.notInSourceModel())
    to t : OUTMODEL!Stereotype mapsTo s (
        isRoot <- s.isRoot,
        isAbstract <- s.isAbstract,
        baseClass <- s.baseClass,
        visibility <- s.visibility,
        name <- s.name,
        icon <- s.icon,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        templateParameter <- s.templateParameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        generalization <- s.generalization,
        comment <- s.comment,
        definedTag <- s.definedTag,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow,
        stereotypeConstraint <- s.stereotypeConstraint,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeMethod {
    from s : MERGEMODEL!Method (s.notInSourceModel())
    to t : OUTMODEL!Method mapsTo s (
        body <- s.body,
        ownerScope <- s.ownerScope,
        visibility <- s.visibility,
        isQuery <- s.isQuery,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        parameter <- s.parameter,
        targetFlow <- s.targetFlow,
        taggedValue <- s.taggedValue,
        comment <- s.comment,
        specification <- s.specification,
        constraint <- s.constraint,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        clientDependency <- s.clientDependency,
        sourceFlow <- s.sourceFlow)
}

rule MergeException {
    from s : MERGEMODEL!Exception (s.notInSourceModel())
    to t : OUTMODEL!Exception mapsTo s (
        isRoot <- s.isRoot,
        name <- s.name,
        isAbstract <- s.isAbstract,
        visibility <- s.visibility,
        isSpecification <- s.isSpecification,
        isLeaf <- s.isLeaf,
        taggedValue <- s.taggedValue,
        sourceFlow <- s.sourceFlow,
        targetFlow <- s.targetFlow,
        clientDependency <- s.clientDependency,
        powertypeRange <- s.powertypeRange,
        "context" <- s."context",
        ownedElement <- s.ownedElement,
        templateParameter <- s.templateParameter,
        constraint <- s.constraint,
        feature <- s.feature,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        generalization <- s.generalization,
        comment <- s.comment,
		namespace <- if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif)
}

rule MergeCallEvent {
    from s : MERGEMODEL!CallEvent (s.notInSourceModel())
    to t : OUTMODEL!CallEvent mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        operation <- if s.operation.oclIsUndefined()
			then s.operation
			else if s.operation.notInSourceModel()
			then s.operation
			else s.operation.fromSourceModel() endif endif,
        parameter <- s.parameter,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.oclIsUndefined()
			then s.namespace
			else if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif endif)
}

rule MergeCallAction {
    from s : MERGEMODEL!CallAction (s.notInSourceModel())
    to t : OUTMODEL!CallAction mapsTo s (
        script <- s.script,
        target <- s.target,
        visibility <- s.visibility,
        isAsynchronous <- s.isAsynchronous,
        name <- s.name,
        isSpecification <- s.isSpecification,
        recurrence <- s.recurrence,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        actualArgument <- s.actualArgument,
        operation <- if s.operation.oclIsUndefined()
			then s.operation
			else if s.operation.notInSourceModel()
			then s.operation
			else s.operation.fromSourceModel() endif endif,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.oclIsUndefined()
			then s.namespace
			else if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif endif)
}

rule MergeStateMachine {
    from s : MERGEMODEL!StateMachine (s.oclIsTypeOf(MERGEMODEL!StateMachine)
    	and s.notInSourceModel())
    to t : OUTMODEL!StateMachine mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        submachineState <- s.submachineState,
        comment <- s.comment,
        top <- s.top,
        taggedValue <- s.taggedValue,
        transitions <- s.transitions,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        sourceFlow <- s.sourceFlow,
		"context" <- if s."context".notInSourceModel()
			then s."context"
			else s."context".fromSourceModel() endif)
}

rule MergeCompositeState {
    from s : MERGEMODEL!CompositeState (s.oclIsTypeOf(MERGEMODEL!CompositeState)
    	and s.notInSourceModel())
    to t : OUTMODEL!CompositeState mapsTo s (
        isConcurrent <- s.isConcurrent,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        entry <- s.entry,
        deferrableEvent <- s.deferrableEvent,
        taggedValue <- s.taggedValue,
        incoming <- s.incoming,
        clientDependency <- s.clientDependency,
        doActivity <- s.doActivity,
        constraint <- s.constraint,
        exit <- s.exit,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        subvertex <- s.subvertex,
        outgoing <- s.outgoing,
        internalTransition <- s.internalTransition,
        sourceFlow <- s.sourceFlow,
		stateMachine <- if s.stateMachine.oclIsUndefined()
			then s.stateMachine
			else if s.stateMachine.notInSourceModel()
			then s.stateMachine
			else s.stateMachine.fromSourceModel() endif endif,
		container <- if s.container.oclIsUndefined()
        	then s.container
			else if s.container.notInSourceModel()
			then s.container
			else s.container.fromSourceModel() endif endif)
}

rule MergePseudostate {
    from s : MERGEMODEL!Pseudostate (s.notInSourceModel())
    to t : OUTMODEL!Pseudostate mapsTo s (
        visibility <- s.visibility,
        kind <- s.kind,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        incoming <- s.incoming,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        outgoing <- s.outgoing,
        sourceFlow <- s.sourceFlow,
		container <- if s.container.notInSourceModel()
			then s.container
			else s.container.fromSourceModel() endif)
}

rule MergeSimpleState {
    from s : MERGEMODEL!SimpleState (s.oclIsTypeOf(MERGEMODEL!SimpleState)
    	and s.notInSourceModel())
    to t : OUTMODEL!SimpleState mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        entry <- s.entry,
        deferrableEvent <- s.deferrableEvent,
        taggedValue <- s.taggedValue,
        incoming <- s.incoming,
        clientDependency <- s.clientDependency,
        doActivity <- s.doActivity,
        constraint <- s.constraint,
        exit <- s.exit,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        outgoing <- s.outgoing,
        internalTransition <- s.internalTransition,
        sourceFlow <- s.sourceFlow,
		container <- if s.container.notInSourceModel()
			then s.container
			else s.container.fromSourceModel() endif)
}

rule MergeTransition {
    from s : MERGEMODEL!Transition (s.notInSourceModel())
    to t : OUTMODEL!Transition mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        guard <- s.guard,
        comment <- s.comment,
        trigger <- s.trigger,
		target <- if s.target.notInSourceModel()
			then s.target
			else s.target.fromSourceModel() endif,
        effect <- s.effect,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
		source <- if s.source.notInSourceModel()
			then s.source
			else s.source.fromSourceModel() endif,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        sourceFlow <- s.sourceFlow,
		stateMachine <- if s.stateMachine.oclIsUndefined()
			then s.stateMachine
			else if s.stateMachine.notInSourceModel()
			then s.stateMachine
			else s.stateMachine.fromSourceModel() endif endif)
}

rule MergeGuard {
    from s : MERGEMODEL!Guard (s.notInSourceModel())
    to t : OUTMODEL!Guard mapsTo s (
        expression <- s.expression,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype->collect(e|if e.notInSourceModel()
        	then e else e.fromSourceModel() endif),
        sourceFlow <- s.sourceFlow,
		namespace <- if s.namespace.oclIsUndefined()
			then s.namespace
			else if s.namespace.notInSourceModel()
			then s.namespace
			else s.namespace.fromSourceModel() endif endif)
}

-- ======================================================================
-- model merge end
-- ======================================================================

-- ======================================================================
-- model copy begin
-- ======================================================================
-- Generated by: ModelCopyGenerator.atl 1515 2005-06-15 14:41:07Z dwagelaa $

rule UseCase {
    from s : INMODEL!UseCase
    to t : OUTMODEL!UseCase mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        feature <- s.feature,
        extend <- s.extend,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        include <- s.include,
        powertypeRange <- s.powertypeRange,
        clientDependency <- s.clientDependency,
        extensionPoint <- s.extensionPoint,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule AssociationEnd {
    from s : INMODEL!AssociationEnd (s.oclIsTypeOf(INMODEL!AssociationEnd))
    to t : OUTMODEL!AssociationEnd mapsTo s (
        multiplicity <- s.multiplicity,
        aggregation <- s.aggregation,
        visibility <- s.visibility,
        targetScope <- s.targetScope,
        changeability <- s.changeability,
        name <- s.name,
        isSpecification <- s.isSpecification,
        ordering <- s.ordering,
        isNavigable <- s.isNavigable,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        qualifier <- s.qualifier,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        specification <- s.specification,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        participant <- s.participant,
        sourceFlow <- s.sourceFlow)
}

rule Actor {
    from s : INMODEL!Actor
    to t : OUTMODEL!Actor mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        feature <- s.feature,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        powertypeRange <- s.powertypeRange,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Interface {
    from s : INMODEL!Interface
    to t : OUTMODEL!Interface mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        feature <- s.feature,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        powertypeRange <- s.powertypeRange,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Stereotype {
    from s : INMODEL!Stereotype
    to t : OUTMODEL!Stereotype mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        baseClass <- s.baseClass,
        icon <- s.icon,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        stereotypeConstraint <- s.stereotypeConstraint,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        definedTag <- s.definedTag,
        sourceFlow <- s.sourceFlow)
}

rule Dependency {
    from s : INMODEL!Dependency (s.oclIsTypeOf(INMODEL!Dependency))
    to t : OUTMODEL!Dependency mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        client <- s.client,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        supplier <- s.supplier,
        sourceFlow <- s.sourceFlow)
}

rule Association {
    from s : INMODEL!Association (s.oclIsTypeOf(INMODEL!Association))
    to t : OUTMODEL!Association mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        connection <- s.connection,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Collaboration {
    from s : INMODEL!Collaboration
    to t : OUTMODEL!Collaboration mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        representedOperation <- s.representedOperation,
        constrainingElement <- s.constrainingElement,
        usedCollaboration <- s.usedCollaboration,
        representedClassifier <- s.representedClassifier,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow,
        interaction <- s.interaction)
}

rule Message {
    from s : INMODEL!Message
    to t : OUTMODEL!Message mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        conformingStimulus <- s.conformingStimulus,
        comment <- s.comment,
        action <- s.action,
        receiver <- s.receiver,
        sender <- s.sender,
        taggedValue <- s.taggedValue,
        predecessor <- s.predecessor,
        clientDependency <- s.clientDependency,
        communicationConnection <- s.communicationConnection,
        activator <- s.activator,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Include {
    from s : INMODEL!Include
    to t : OUTMODEL!Include mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        base <- s.base,
        clientDependency <- s.clientDependency,
        addition <- s.addition,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule DataType {
    from s : INMODEL!DataType (s.oclIsTypeOf(INMODEL!DataType))
    to t : OUTMODEL!DataType mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        feature <- s.feature,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        powertypeRange <- s.powertypeRange,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Operation {
    from s : INMODEL!Operation
    to t : OUTMODEL!Operation mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        specification <- s.specification,
        name <- s.name,
        isQuery <- s.isQuery,
        isSpecification <- s.isSpecification,
        ownerScope <- s.ownerScope,
        concurrency <- s.concurrency,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        parameter <- s.parameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule CollaborationInstanceSet {
    from s : INMODEL!CollaborationInstanceSet
    to t : OUTMODEL!CollaborationInstanceSet mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        interactionInstanceSet <- s.interactionInstanceSet,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        participatingLink <- s.participatingLink,
        collaboration <- s.collaboration,
        constrainingElement <- s.constrainingElement,
        taggedValue <- s.taggedValue,
        participatingInstance <- s.participatingInstance,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Parameter {
    from s : INMODEL!Parameter
    to t : OUTMODEL!Parameter mapsTo s (
        visibility <- s.visibility,
        kind <- s.kind,
        defaultValue <- s.defaultValue,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        type <- s.type,
        sourceFlow <- s.sourceFlow)
}

rule Pseudostate {
    from s : INMODEL!Pseudostate
    to t : OUTMODEL!Pseudostate mapsTo s (
        visibility <- s.visibility,
        kind <- s.kind,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        incoming <- s.incoming,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        outgoing <- s.outgoing,
        sourceFlow <- s.sourceFlow)
}

rule Class {
    from s : INMODEL!Class (s.oclIsTypeOf(INMODEL!Class))
    to t : OUTMODEL!Class mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        feature <- s.feature,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        powertypeRange <- s.powertypeRange,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Expression {
    from s : INMODEL!Expression (s.oclIsTypeOf(INMODEL!Expression))
    to t : OUTMODEL!Expression mapsTo s (
        body <- s.body,
        language <- s.language)
}

rule ProcedureExpression {
    from s : INMODEL!ProcedureExpression
    to t : OUTMODEL!ProcedureExpression mapsTo s (
        body <- s.body,
        language <- s.language)
}

rule CallEvent {
    from s : INMODEL!CallEvent
    to t : OUTMODEL!CallEvent mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        operation <- s.operation,
        parameter <- s.parameter,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule MultiplicityRange {
    from s : INMODEL!MultiplicityRange
    to t : OUTMODEL!MultiplicityRange mapsTo s (
        upper <- s.upper,
        lower <- s.lower)
}

rule StateMachine {
    from s : INMODEL!StateMachine (s.oclIsTypeOf(INMODEL!StateMachine))
    to t : OUTMODEL!StateMachine mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        submachineState <- s.submachineState,
        comment <- s.comment,
        top <- s.top,
        taggedValue <- s.taggedValue,
        transitions <- s.transitions,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule CallAction {
    from s : INMODEL!CallAction
    to t : OUTMODEL!CallAction mapsTo s (
        script <- s.script,
        target <- s.target,
        visibility <- s.visibility,
        isAsynchronous <- s.isAsynchronous,
        name <- s.name,
        isSpecification <- s.isSpecification,
        recurrence <- s.recurrence,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        actualArgument <- s.actualArgument,
        operation <- s.operation,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Package {
    from s : INMODEL!Package (s.oclIsTypeOf(INMODEL!Package))
    to t : OUTMODEL!Package mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        elementImport <- s.elementImport,
        comment <- s.comment,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Abstraction {
    from s : INMODEL!Abstraction
    to t : OUTMODEL!Abstraction mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        mapping <- s.mapping,
        templateParameter <- s.templateParameter,
        client <- s.client,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        supplier <- s.supplier,
        sourceFlow <- s.sourceFlow)
}

rule BooleanExpression {
    from s : INMODEL!BooleanExpression
    to t : OUTMODEL!BooleanExpression mapsTo s (
        body <- s.body,
        language <- s.language)
}

rule ReturnAction {
    from s : INMODEL!ReturnAction
    to t : OUTMODEL!ReturnAction mapsTo s (
        script <- s.script,
        target <- s.target,
        visibility <- s.visibility,
        isAsynchronous <- s.isAsynchronous,
        name <- s.name,
        isSpecification <- s.isSpecification,
        recurrence <- s.recurrence,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        actualArgument <- s.actualArgument,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Argument {
    from s : INMODEL!Argument
    to t : OUTMODEL!Argument mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        value <- s.value,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule InteractionInstanceSet {
    from s : INMODEL!InteractionInstanceSet
    to t : OUTMODEL!InteractionInstanceSet mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        interaction <- s.interaction,
        clientDependency <- s.clientDependency,
        participatingStimulus <- s.participatingStimulus,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule LinkEnd {
    from s : INMODEL!LinkEnd
    to t : OUTMODEL!LinkEnd mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        instance <- s.instance,
        taggedValue <- s.taggedValue,
        qualifiedValue <- s.qualifiedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        associationEnd <- s.associationEnd,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule TaggedValue {
    from s : INMODEL!TaggedValue
    to t : OUTMODEL!TaggedValue mapsTo s (
        dataValue <- s.dataValue,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        type <- s.type,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        referenceValue <- s.referenceValue,
        sourceFlow <- s.sourceFlow)
}

rule SimpleState {
    from s : INMODEL!SimpleState (s.oclIsTypeOf(INMODEL!SimpleState))
    to t : OUTMODEL!SimpleState mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        entry <- s.entry,
        deferrableEvent <- s.deferrableEvent,
        taggedValue <- s.taggedValue,
        incoming <- s.incoming,
        clientDependency <- s.clientDependency,
        doActivity <- s.doActivity,
        constraint <- s.constraint,
        exit <- s.exit,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        outgoing <- s.outgoing,
        internalTransition <- s.internalTransition,
        sourceFlow <- s.sourceFlow)
}

rule Generalization {
    from s : INMODEL!Generalization
    to t : OUTMODEL!Generalization mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        discriminator <- s.discriminator,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        child <- s.child,
        taggedValue <- s.taggedValue,
        powertype <- s.powertype,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        parent <- s.parent,
        sourceFlow <- s.sourceFlow)
}

rule Multiplicity {
    from s : INMODEL!Multiplicity
    to t : OUTMODEL!Multiplicity mapsTo s (
        range <- s.range)
}

rule Object {
    from s : INMODEL!Object (s.oclIsTypeOf(INMODEL!Object))
    to t : OUTMODEL!Object mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        ownedLink <- s.ownedLink,
        classifier <- s.classifier,
        slot <- s.slot,
        taggedValue <- s.taggedValue,
        linkEnd <- s.linkEnd,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        ownedInstance <- s.ownedInstance,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        componentInstance <- s.componentInstance,
        sourceFlow <- s.sourceFlow)
}

rule TagDefinition {
    from s : INMODEL!TagDefinition
    to t : OUTMODEL!TagDefinition mapsTo s (
        multiplicity <- s.multiplicity,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        tagType <- s.tagType,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Model {
    from s : INMODEL!Model
    to t : OUTMODEL!Model mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        elementImport <- s.elementImport,
        comment <- s.comment,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Exception {
    from s : INMODEL!Exception
    to t : OUTMODEL!Exception mapsTo s (
        isLeaf <- s.isLeaf,
        isRoot <- s.isRoot,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        isAbstract <- s.isAbstract,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        "context" <- s."context",
        feature <- s.feature,
        ownedElement <- s.ownedElement,
        taggedValue <- s.taggedValue,
        powertypeRange <- s.powertypeRange,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        generalization <- s.generalization,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Transition {
    from s : INMODEL!Transition
    to t : OUTMODEL!Transition mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        guard <- s.guard,
        comment <- s.comment,
        trigger <- s.trigger,
        target <- s.target,
        effect <- s.effect,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        source <- s.source,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Link {
    from s : INMODEL!Link (s.oclIsTypeOf(INMODEL!Link))
    to t : OUTMODEL!Link mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        association <- s.association,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        connection <- s.connection,
        sourceFlow <- s.sourceFlow)
}

rule CompositeState {
    from s : INMODEL!CompositeState (s.oclIsTypeOf(INMODEL!CompositeState))
    to t : OUTMODEL!CompositeState mapsTo s (
        isConcurrent <- s.isConcurrent,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        entry <- s.entry,
        deferrableEvent <- s.deferrableEvent,
        taggedValue <- s.taggedValue,
        incoming <- s.incoming,
        clientDependency <- s.clientDependency,
        doActivity <- s.doActivity,
        constraint <- s.constraint,
        exit <- s.exit,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        subvertex <- s.subvertex,
        outgoing <- s.outgoing,
        internalTransition <- s.internalTransition,
        sourceFlow <- s.sourceFlow)
}

rule Attribute {
    from s : INMODEL!Attribute
    to t : OUTMODEL!Attribute mapsTo s (
        ordering <- s.ordering,
        initialValue <- s.initialValue,
        changeability <- s.changeability,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        ownerScope <- s.ownerScope,
        multiplicity <- s.multiplicity,
        targetScope <- s.targetScope,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        type <- s.type,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Stimulus {
    from s : INMODEL!Stimulus
    to t : OUTMODEL!Stimulus mapsTo s (
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        receiver <- s.receiver,
        sender <- s.sender,
        taggedValue <- s.taggedValue,
        dispatchAction <- s.dispatchAction,
        communicationLink <- s.communicationLink,
        clientDependency <- s.clientDependency,
        argument <- s.argument,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Guard {
    from s : INMODEL!Guard
    to t : OUTMODEL!Guard mapsTo s (
        expression <- s.expression,
        visibility <- s.visibility,
        name <- s.name,
        isSpecification <- s.isSpecification,
        templateParameter <- s.templateParameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

rule Method {
    from s : INMODEL!Method
    to t : OUTMODEL!Method mapsTo s (
        body <- s.body,
        visibility <- s.visibility,
        name <- s.name,
        isQuery <- s.isQuery,
        isSpecification <- s.isSpecification,
        ownerScope <- s.ownerScope,
        templateParameter <- s.templateParameter,
        parameter <- s.parameter,
        comment <- s.comment,
        taggedValue <- s.taggedValue,
        specification <- s.specification,
        clientDependency <- s.clientDependency,
        constraint <- s.constraint,
        targetFlow <- s.targetFlow,
        stereotype <- s.stereotype,
        sourceFlow <- s.sourceFlow)
}

-- ======================================================================
-- model copy end
-- ======================================================================