info-loss/fr.tpt.mem4csd.loss.mm2loss/face2loss.atl

module face2loss;

create LOSS : OUT from MM : IN;

lazy rule DTface__uop__FaceProfile2Prim {
	from
	source : IN!"face::uop::FaceProfile" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

lazy rule DTface__uop__SynchronizationStyle2Prim {
	from
	source : IN!"face::uop::SynchronizationStyle" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__datamodel__platform__Participant2Complex {
	from
	source : IN!"face::datamodel::platform::Participant" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Participant"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes)).add(thisModule.ReferenceToLink(source.type)).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.path))
	)
}

rule CLface__integration__UoPEndPoint2Complex {
	from
	source : IN!"face::integration::UoPEndPoint" in MM (source.oclIsTypeOf(IN!"face::integration::UoPEndPoint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.connection))
	)
}

rule CLface__datamodel__logical__Unit2Complex {
	from
	source : IN!"face::datamodel::logical::Unit" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Unit"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__conceptual__ComposableElement2Complex {
	from
	source : IN!"face::datamodel::conceptual::ComposableElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::ComposableElement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__Element2Complex {
	from
	source : IN!"face::Element" in MM (source.oclIsTypeOf(IN!"face::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__Boolean2Complex {
	from
	source : IN!"face::datamodel::logical::Boolean" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Boolean"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__traceability__UoPTraceabilitySet2Complex {
	from
	source : IN!"face::traceability::UoPTraceabilitySet" in MM (source.oclIsTypeOf(IN!"face::traceability::UoPTraceabilitySet"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.uop->collect(it | thisModule.ReferenceToLink(it))).union(source.abstractUoP->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__LongLong2Complex {
	from
	source : IN!"face::datamodel::platform::LongLong" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::LongLong"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__uop__UoPModel2Complex {
	from
	source : IN!"face::uop::UoPModel" in MM (source.oclIsTypeOf(IN!"face::uop::UoPModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.element->collect(it | thisModule.ReferenceToLink(it))).union(source.um->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__traceability__TraceableElement2Complex {
	from
	source : IN!"face::traceability::TraceableElement" in MM (source.oclIsTypeOf(IN!"face::traceability::TraceableElement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__IDLArray2Complex {
	from
	source : IN!"face::datamodel::platform::IDLArray" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLArray"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__LogicalDataModel2Complex {
	from
	source : IN!"face::datamodel::LogicalDataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::LogicalDataModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.element->collect(it | thisModule.ReferenceToLink(it))).union(source.ldm->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__logical__StandardMeasurementSystem2Complex {
	from
	source : IN!"face::datamodel::logical::StandardMeasurementSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::StandardMeasurementSystem"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__uop__PubSubConnection2Complex {
	from
	source : IN!"face::uop::PubSubConnection" in MM (source.oclIsTypeOf(IN!"face::uop::PubSubConnection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.messageType))
	)
}

rule CLface__datamodel__platform__BoundedString2Complex {
	from
	source : IN!"face::datamodel::platform::BoundedString" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::BoundedString"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__ComposableElement2Complex {
	from
	source : IN!"face::datamodel::platform::ComposableElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ComposableElement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__integration__ViewTransporter2Complex {
	from
	source : IN!"face::integration::ViewTransporter" in MM (source.oclIsTypeOf(IN!"face::integration::ViewTransporter"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort)).add(thisModule.ReferenceToLink(source.channel))
	)
}

rule CLface__datamodel__platform__IDLBoundedString2Complex {
	from
	source : IN!"face::datamodel::platform::IDLBoundedString" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLBoundedString"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__integration__UoPInputEndPoint2Complex {
	from
	source : IN!"face::integration::UoPInputEndPoint" in MM (source.oclIsTypeOf(IN!"face::integration::UoPInputEndPoint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.connection))
	)
}

rule CLface__datamodel__logical__Enumerated2Complex {
	from
	source : IN!"face::datamodel::logical::Enumerated" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Enumerated"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.label->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__integration__TransportChannel2Complex {
	from
	source : IN!"face::integration::TransportChannel" in MM (source.oclIsTypeOf(IN!"face::integration::TransportChannel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__integration__ViewTransformation2Complex {
	from
	source : IN!"face::integration::ViewTransformation" in MM (source.oclIsTypeOf(IN!"face::integration::ViewTransformation"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort))
	)
}

rule CLface__datamodel__platform__CharArray2Complex {
	from
	source : IN!"face::datamodel::platform::CharArray" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CharArray"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__uop__LifeCycleManagementPort2Complex {
	from
	source : IN!"face::uop::LifeCycleManagementPort" in MM (source.oclIsTypeOf(IN!"face::uop::LifeCycleManagementPort"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.lcmMessageType))
	)
}

rule CLface__datamodel__logical__Characteristic2Complex {
	from
	source : IN!"face::datamodel::logical::Characteristic" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Characteristic"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes))
	)
}

rule CLface__datamodel__platform__CharacteristicPathNode2Complex {
	from
	source : IN!"face::datamodel::platform::CharacteristicPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CharacteristicPathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node)).add(thisModule.ReferenceToLink(source.projectedCharacteristic))
	)
}

rule CLface__datamodel__logical__MeasurementConversion2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementConversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementConversion"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.source)).add(thisModule.ReferenceToLink(source.target))
	)
}

rule CLface__datamodel__platform__IDLStruct2Complex {
	from
	source : IN!"face::datamodel::platform::IDLStruct" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLStruct"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes)).union(source.composition->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__Template2Complex {
	from
	source : IN!"face::datamodel::platform::Template" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Template"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.boundQuery)).add(thisModule.ReferenceToLink(source.effectiveQuery))
	)
}

rule CLface__traceability__TraceabilityPoint2Complex {
	from
	source : IN!"face::traceability::TraceabilityPoint" in MM (source.oclIsTypeOf(IN!"face::traceability::TraceabilityPoint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__Enumeration2Complex {
	from
	source : IN!"face::datamodel::platform::Enumeration" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Enumeration"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__IDLType2Complex {
	from
	source : IN!"face::datamodel::platform::IDLType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLType"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__Association2Complex {
	from
	source : IN!"face::datamodel::logical::Association" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Association"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.specializes)).union(source.participant->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__IDLUnsignedInteger2Complex {
	from
	source : IN!"face::datamodel::platform::IDLUnsignedInteger" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLUnsignedInteger"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__CharType2Complex {
	from
	source : IN!"face::datamodel::platform::CharType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CharType"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__LongDouble2Complex {
	from
	source : IN!"face::datamodel::platform::LongDouble" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::LongDouble"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__ComposableElement2Complex {
	from
	source : IN!"face::datamodel::logical::ComposableElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ComposableElement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__Integer2Complex {
	from
	source : IN!"face::datamodel::logical::Integer" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Integer"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__DataModel2Complex {
	from
	source : IN!"face::datamodel::DataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::DataModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.cdm->collect(it | thisModule.ReferenceToLink(it))).union(source.ldm->collect(it | thisModule.ReferenceToLink(it))).union(source.pdm->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__uop__Thread2Complex {
	from
	source : IN!"face::uop::Thread" in MM (source.oclIsTypeOf(IN!"face::uop::Thread"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__ConceptualDataModel2Complex {
	from
	source : IN!"face::datamodel::ConceptualDataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::ConceptualDataModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.element->collect(it | thisModule.ReferenceToLink(it))).union(source.cdm->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__StringType2Complex {
	from
	source : IN!"face::datamodel::platform::StringType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::StringType"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__Natural2Complex {
	from
	source : IN!"face::datamodel::logical::Natural" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Natural"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__Character2Complex {
	from
	source : IN!"face::datamodel::logical::Character" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Character"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__EnumerationLabel2Complex {
	from
	source : IN!"face::datamodel::logical::EnumerationLabel" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::EnumerationLabel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__ValueType2Complex {
	from
	source : IN!"face::datamodel::logical::ValueType" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ValueType"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__PathNode2Complex {
	from
	source : IN!"face::datamodel::logical::PathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::PathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node))
	)
}

rule CLface__datamodel__logical__MeasurementSystemAxis2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementSystemAxis" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementSystemAxis"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.axis)).union(source.defaultValueTypeUnit->collect(it | thisModule.ReferenceToLink(it))).union(source.constraint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__IDLReal2Complex {
	from
	source : IN!"face::datamodel::platform::IDLReal" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLReal"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__Short2Complex {
	from
	source : IN!"face::datamodel::platform::Short" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Short"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__conceptual__Query2Complex {
	from
	source : IN!"face::datamodel::conceptual::Query" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Query"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__IDLCharacterArray2Complex {
	from
	source : IN!"face::datamodel::platform::IDLCharacterArray" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLCharacterArray"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__RealConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::RealConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::RealConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__MeasurementConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__ParticipantPathNode2Complex {
	from
	source : IN!"face::datamodel::platform::ParticipantPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ParticipantPathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node)).add(thisModule.ReferenceToLink(source.projectedParticipant))
	)
}

rule CLface__traceability__Element2Complex {
	from
	source : IN!"face::traceability::Element" in MM (source.oclIsTypeOf(IN!"face::traceability::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__AffineConversion2Complex {
	from
	source : IN!"face::datamodel::logical::AffineConversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::AffineConversion"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.destination)).add(thisModule.ReferenceToLink(source.source))
	)
}

rule CLface__datamodel__logical__Participant2Complex {
	from
	source : IN!"face::datamodel::logical::Participant" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Participant"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes)).add(thisModule.ReferenceToLink(source.type)).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.path))
	)
}

rule CLface__integration__ViewSink2Complex {
	from
	source : IN!"face::integration::ViewSink" in MM (source.oclIsTypeOf(IN!"face::integration::ViewSink"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort))
	)
}

lazy rule DTface__uop__ProgrammingLanguage2Prim {
	from
	source : IN!"face::uop::ProgrammingLanguage" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__integration__TSNodeInputPort2Complex {
	from
	source : IN!"face::integration::TSNodeInputPort" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodeInputPort"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.view))
	)
}

rule CLface__datamodel__platform__PhysicalDataType2Complex {
	from
	source : IN!"face::datamodel::platform::PhysicalDataType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::PhysicalDataType"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__RealRangeConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::RealRangeConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::RealRangeConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__Element2Complex {
	from
	source : IN!"face::datamodel::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__uop__SingleInstanceMessageConnection2Complex {
	from
	source : IN!"face::uop::SingleInstanceMessageConnection" in MM (source.oclIsTypeOf(IN!"face::uop::SingleInstanceMessageConnection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.messageType))
	)
}

rule CLface__datamodel__conceptual__Element2Complex {
	from
	source : IN!"face::datamodel::conceptual::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__uop__Element2Complex {
	from
	source : IN!"face::uop::Element" in MM (source.oclIsTypeOf(IN!"face::uop::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__TemplateComposition2Complex {
	from
	source : IN!"face::datamodel::platform::TemplateComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::TemplateComposition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.type))
	)
}

rule CLface__datamodel__logical__IntegerRangeConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::IntegerRangeConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::IntegerRangeConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__IDLSequence2Complex {
	from
	source : IN!"face::datamodel::platform::IDLSequence" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLSequence"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__Numeric2Complex {
	from
	source : IN!"face::datamodel::logical::Numeric" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Numeric"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

lazy rule DTface__uop__ThreadType2Prim {
	from
	source : IN!"face::uop::ThreadType" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__datamodel__logical__String2Complex {
	from
	source : IN!"face::datamodel::logical::String" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::String"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__conceptual__CompositeQuery2Complex {
	from
	source : IN!"face::datamodel::conceptual::CompositeQuery" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::CompositeQuery"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__logical__Query2Complex {
	from
	source : IN!"face::datamodel::logical::Query" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Query"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__conceptual__Observable2Complex {
	from
	source : IN!"face::datamodel::conceptual::Observable" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Observable"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__MeasurementSystemConversion2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementSystemConversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementSystemConversion"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.source)).add(thisModule.ReferenceToLink(source.target))
	)
}

rule CLface__datamodel__logical__View2Complex {
	from
	source : IN!"face::datamodel::logical::View" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::View"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__Fixed2Complex {
	from
	source : IN!"face::datamodel::platform::Fixed" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Fixed"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__IDLComposition2Complex {
	from
	source : IN!"face::datamodel::platform::IDLComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLComposition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.type)).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__integration__ViewFilter2Complex {
	from
	source : IN!"face::integration::ViewFilter" in MM (source.oclIsTypeOf(IN!"face::integration::ViewFilter"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort))
	)
}

rule CLface__traceability__TraceabilityModel2Complex {
	from
	source : IN!"face::traceability::TraceabilityModel" in MM (source.oclIsTypeOf(IN!"face::traceability::TraceabilityModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.element->collect(it | thisModule.ReferenceToLink(it))).union(source.tm->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__logical__Composition2Complex {
	from
	source : IN!"face::datamodel::logical::Composition" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Composition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes)).add(thisModule.ReferenceToLink(source.type)).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__uop__RAMMemoryRequirements2Complex {
	from
	source : IN!"face::uop::RAMMemoryRequirements" in MM (source.oclIsTypeOf(IN!"face::uop::RAMMemoryRequirements"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__integration__IntegrationContext2Complex {
	from
	source : IN!"face::integration::IntegrationContext" in MM (source.oclIsTypeOf(IN!"face::integration::IntegrationContext"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.connection->collect(it | thisModule.ReferenceToLink(it))).union(source.node->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__Float2Complex {
	from
	source : IN!"face::datamodel::platform::Float" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Float"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__uop__AbstractConnection2Complex {
	from
	source : IN!"face::uop::AbstractConnection" in MM (source.oclIsTypeOf(IN!"face::uop::AbstractConnection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.conceptualView)).add(thisModule.ReferenceToLink(source.logicalView))
	)
}

rule CLface__datamodel__conceptual__Domain2Complex {
	from
	source : IN!"face::datamodel::conceptual::Domain" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Domain"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.basisEntity->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__integration__TSNodePort2Complex {
	from
	source : IN!"face::integration::TSNodePort" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodePort"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.view))
	)
}

rule CLface__ArchitectureModel2Complex {
	from
	source : IN!"face::ArchitectureModel" in MM (source.oclIsTypeOf(IN!"face::ArchitectureModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.dm->collect(it | thisModule.ReferenceToLink(it))).union(source.um->collect(it | thisModule.ReferenceToLink(it))).union(source.im->collect(it | thisModule.ReferenceToLink(it))).union(source.tm->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__logical__Real2Complex {
	from
	source : IN!"face::datamodel::logical::Real" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Real"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__uop__UnitOfPortability2Complex {
	from
	source : IN!"face::uop::UnitOfPortability" in MM (source.oclIsTypeOf(IN!"face::uop::UnitOfPortability"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.supportingComponent->collect(it | thisModule.ReferenceToLink(it))).union(source.thread->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.memoryRequirements)).add(thisModule.ReferenceToLink(source.realizes)).union(source.connection->collect(it | thisModule.ReferenceToLink(it))).union(source.lcmPort->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__PlatformDataModel2Complex {
	from
	source : IN!"face::datamodel::PlatformDataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::PlatformDataModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.element->collect(it | thisModule.ReferenceToLink(it))).union(source.pdm->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__conceptual__QueryComposition2Complex {
	from
	source : IN!"face::datamodel::conceptual::QueryComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::QueryComposition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.type))
	)
}

rule CLface__datamodel__conceptual__BasisEntity2Complex {
	from
	source : IN!"face::datamodel::conceptual::BasisEntity" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::BasisEntity"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__AbstractMeasurement2Complex {
	from
	source : IN!"face::datamodel::logical::AbstractMeasurement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::AbstractMeasurement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__PathNode2Complex {
	from
	source : IN!"face::datamodel::platform::PathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::PathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node))
	)
}

rule CLface__uop__QueuingConnection2Complex {
	from
	source : IN!"face::uop::QueuingConnection" in MM (source.oclIsTypeOf(IN!"face::uop::QueuingConnection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.messageType))
	)
}

rule CLface__uop__ClientServerConnection2Complex {
	from
	source : IN!"face::uop::ClientServerConnection" in MM (source.oclIsTypeOf(IN!"face::uop::ClientServerConnection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.requestType)).add(thisModule.ReferenceToLink(source.responseType))
	)
}

rule CLface__datamodel__platform__Octet2Complex {
	from
	source : IN!"face::datamodel::platform::Octet" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Octet"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__Double2Complex {
	from
	source : IN!"face::datamodel::platform::Double" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Double"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__Query2Complex {
	from
	source : IN!"face::datamodel::platform::Query" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Query"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__integration__Element2Complex {
	from
	source : IN!"face::integration::Element" in MM (source.oclIsTypeOf(IN!"face::integration::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__NonNegativeReal2Complex {
	from
	source : IN!"face::datamodel::logical::NonNegativeReal" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::NonNegativeReal"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

lazy rule DTface__uop__PartitionType2Prim {
	from
	source : IN!"face::uop::PartitionType" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__datamodel__logical__MeasurementAttribute2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementAttribute" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementAttribute"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.type))
	)
}

rule CLface__uop__AbstractUoP2Complex {
	from
	source : IN!"face::uop::AbstractUoP" in MM (source.oclIsTypeOf(IN!"face::uop::AbstractUoP"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.connection->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__Association2Complex {
	from
	source : IN!"face::datamodel::platform::Association" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Association"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.specializes)).union(source.participant->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__conceptual__Entity2Complex {
	from
	source : IN!"face::datamodel::conceptual::Entity" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Entity"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.specializes)).union(source.basisEntity->collect(it | thisModule.ReferenceToLink(it)))
	)
}

lazy rule DTface__uop__ClientServerRole2Prim {
	from
	source : IN!"face::uop::ClientServerRole" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__integration__ViewAggregation2Complex {
	from
	source : IN!"face::integration::ViewAggregation" in MM (source.oclIsTypeOf(IN!"face::integration::ViewAggregation"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort))
	)
}

rule CLface__datamodel__logical__RegularExpressionConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::RegularExpressionConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::RegularExpressionConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__ParticipantPathNode2Complex {
	from
	source : IN!"face::datamodel::logical::ParticipantPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ParticipantPathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node)).add(thisModule.ReferenceToLink(source.projectedParticipant))
	)
}

rule CLface__datamodel__logical__Element2Complex {
	from
	source : IN!"face::datamodel::logical::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__conceptual__View2Complex {
	from
	source : IN!"face::datamodel::conceptual::View" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::View"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__logical__MeasurementAxis2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementAxis" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementAxis"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.valueTypeUnit->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.measurementSystemAxis)).union(source.constraint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__CoordinateSystemAxis2Complex {
	from
	source : IN!"face::datamodel::logical::CoordinateSystemAxis" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CoordinateSystemAxis"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__FixedLengthStringConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::FixedLengthStringConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::FixedLengthStringConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__integration__TransportNode2Complex {
	from
	source : IN!"face::integration::TransportNode" in MM (source.oclIsTypeOf(IN!"face::integration::TransportNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort))
	)
}

rule CLface__datamodel__logical__CoordinateSystem2Complex {
	from
	source : IN!"face::datamodel::logical::CoordinateSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CoordinateSystem"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.axis->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__IDLPrimitive2Complex {
	from
	source : IN!"face::datamodel::platform::IDLPrimitive" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLPrimitive"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__ConvertibleElement2Complex {
	from
	source : IN!"face::datamodel::logical::ConvertibleElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ConvertibleElement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__ValueTypeUnit2Complex {
	from
	source : IN!"face::datamodel::logical::ValueTypeUnit" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ValueTypeUnit"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.unit)).add(thisModule.ReferenceToLink(source.valueType)).add(thisModule.ReferenceToLink(source.constraint))
	)
}

rule CLface__datamodel__platform__Element2Complex {
	from
	source : IN!"face::datamodel::platform::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Element"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__uop__ComponentFramework2Complex {
	from
	source : IN!"face::uop::ComponentFramework" in MM (source.oclIsTypeOf(IN!"face::uop::ComponentFramework"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__StringConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::StringConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::StringConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__CharacteristicPathNode2Complex {
	from
	source : IN!"face::datamodel::logical::CharacteristicPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CharacteristicPathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node)).add(thisModule.ReferenceToLink(source.projectedCharacteristic))
	)
}

rule CLface__datamodel__logical__MeasurementSystem2Complex {
	from
	source : IN!"face::datamodel::logical::MeasurementSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementSystem"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.measurementSystemAxis->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.coordinateSystem)).union(source.referencePoint->collect(it | thisModule.ReferenceToLink(it))).union(source.constraint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__conceptual__Association2Complex {
	from
	source : IN!"face::datamodel::conceptual::Association" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Association"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.specializes)).union(source.basisEntity->collect(it | thisModule.ReferenceToLink(it))).union(source.participant->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__conceptual__BasisElement2Complex {
	from
	source : IN!"face::datamodel::conceptual::BasisElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::BasisElement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

lazy rule DTface__uop__MessageExchangeType2Prim {
	from
	source : IN!"face::uop::MessageExchangeType" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__datamodel__platform__ULongLong2Complex {
	from
	source : IN!"face::datamodel::platform::ULongLong" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ULongLong"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__Composition2Complex {
	from
	source : IN!"face::datamodel::platform::Composition" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Composition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes)).add(thisModule.ReferenceToLink(source.type)).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__CompositeQuery2Complex {
	from
	source : IN!"face::datamodel::logical::CompositeQuery" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CompositeQuery"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__uop__SupportingComponent2Complex {
	from
	source : IN!"face::uop::SupportingComponent" in MM (source.oclIsTypeOf(IN!"face::uop::SupportingComponent"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__IDLNumber2Complex {
	from
	source : IN!"face::datamodel::platform::IDLNumber" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLNumber"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__Constraint2Complex {
	from
	source : IN!"face::datamodel::logical::Constraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Constraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__conceptual__Characteristic2Complex {
	from
	source : IN!"face::datamodel::conceptual::Characteristic" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Characteristic"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes))
	)
}

rule CLface__integration__TSNodeOutputPort2Complex {
	from
	source : IN!"face::integration::TSNodeOutputPort" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodeOutputPort"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.view))
	)
}

rule CLface__datamodel__logical__Measurement2Complex {
	from
	source : IN!"face::datamodel::logical::Measurement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Measurement"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.constraint->collect(it | thisModule.ReferenceToLink(it))).union(source.measurementAxis->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.measurementSystem)).add(thisModule.ReferenceToLink(source.realizes)).union(source.attribute->collect(it | thisModule.ReferenceToLink(it)))
	)
}

lazy rule DTface__uop__DesignAssuranceLevel2Prim {
	from
	source : IN!"face::uop::DesignAssuranceLevel" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__datamodel__logical__Conversion2Complex {
	from
	source : IN!"face::datamodel::logical::Conversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Conversion"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.destination)).add(thisModule.ReferenceToLink(source.source))
	)
}

rule CLface__datamodel__logical__ReferencePoint2Complex {
	from
	source : IN!"face::datamodel::logical::ReferencePoint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ReferencePoint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.referencePointPart->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.landmark))
	)
}

rule CLface__datamodel__logical__IntegerConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::IntegerConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::IntegerConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__uop__PortableComponent2Complex {
	from
	source : IN!"face::uop::PortableComponent" in MM (source.oclIsTypeOf(IN!"face::uop::PortableComponent"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.supportingComponent->collect(it | thisModule.ReferenceToLink(it))).union(source.thread->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.memoryRequirements)).add(thisModule.ReferenceToLink(source.realizes)).union(source.connection->collect(it | thisModule.ReferenceToLink(it))).union(source.lcmPort->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__ULong2Complex {
	from
	source : IN!"face::datamodel::platform::ULong" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ULong"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__ReferencePointPart2Complex {
	from
	source : IN!"face::datamodel::logical::ReferencePointPart" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ReferencePointPart"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.axis)).add(thisModule.ReferenceToLink(source.valueTypeUnit))
	)
}

rule CLface__datamodel__platform__String2Complex {
	from
	source : IN!"face::datamodel::platform::String" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::String"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__Entity2Complex {
	from
	source : IN!"face::datamodel::platform::Entity" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Entity"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.specializes))
	)
}

rule CLface__datamodel__logical__Landmark2Complex {
	from
	source : IN!"face::datamodel::logical::Landmark" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Landmark"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__platform__IDLUnboundedString2Complex {
	from
	source : IN!"face::datamodel::platform::IDLUnboundedString" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLUnboundedString"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__EnumerationConstraint2Complex {
	from
	source : IN!"face::datamodel::logical::EnumerationConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::EnumerationConstraint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.allowedValue->collect(it | thisModule.ReferenceToLink(it)))
	)
}

lazy rule DTface__uop__DesignAssuranceStandard2Prim {
	from
	source : IN!"face::uop::DesignAssuranceStandard" in MM
	to
	prim : OUT!Primitive (
		name <- source.toString()
	)
}

rule CLface__integration__ViewSource2Complex {
	from
	source : IN!"face::integration::ViewSource" in MM (source.oclIsTypeOf(IN!"face::integration::ViewSource"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.outPort)).add(thisModule.ReferenceToLink(source.inPort))
	)
}

rule CLface__datamodel__platform__IDLInteger2Complex {
	from
	source : IN!"face::datamodel::platform::IDLInteger" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLInteger"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__uop__PlatformSpecificComponent2Complex {
	from
	source : IN!"face::uop::PlatformSpecificComponent" in MM (source.oclIsTypeOf(IN!"face::uop::PlatformSpecificComponent"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.supportingComponent->collect(it | thisModule.ReferenceToLink(it))).union(source.thread->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.memoryRequirements)).add(thisModule.ReferenceToLink(source.realizes)).union(source.connection->collect(it | thisModule.ReferenceToLink(it))).union(source.lcmPort->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__platform__Characteristic2Complex {
	from
	source : IN!"face::datamodel::platform::Characteristic" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Characteristic"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes))
	)
}

rule CLface__datamodel__platform__Char2Complex {
	from
	source : IN!"face::datamodel::platform::Char" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Char"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__UShort2Complex {
	from
	source : IN!"face::datamodel::platform::UShort" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::UShort"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__integration__UoPOutputEndPoint2Complex {
	from
	source : IN!"face::integration::UoPOutputEndPoint" in MM (source.oclIsTypeOf(IN!"face::integration::UoPOutputEndPoint"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.connection))
	)
}

rule CLface__uop__LanguageRunTime2Complex {
	from
	source : IN!"face::uop::LanguageRunTime" in MM (source.oclIsTypeOf(IN!"face::uop::LanguageRunTime"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__conceptual__CharacteristicPathNode2Complex {
	from
	source : IN!"face::datamodel::conceptual::CharacteristicPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::CharacteristicPathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node)).add(thisModule.ReferenceToLink(source.projectedCharacteristic))
	)
}

rule CLface__datamodel__platform__Boolean2Complex {
	from
	source : IN!"face::datamodel::platform::Boolean" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Boolean"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__conceptual__ParticipantPathNode2Complex {
	from
	source : IN!"face::datamodel::conceptual::ParticipantPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::ParticipantPathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node)).add(thisModule.ReferenceToLink(source.projectedParticipant))
	)
}

rule CLface__datamodel__platform__View2Complex {
	from
	source : IN!"face::datamodel::platform::View" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::View"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__conceptual__Composition2Complex {
	from
	source : IN!"face::datamodel::conceptual::Composition" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Composition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes)).add(thisModule.ReferenceToLink(source.type))
	)
}

rule CLface__datamodel__conceptual__Participant2Complex {
	from
	source : IN!"face::datamodel::conceptual::Participant" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Participant"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.specializes)).add(thisModule.ReferenceToLink(source.type)).add(thisModule.ReferenceToLink(source.path))
	)
}

rule CLface__integration__UoPInstance2Complex {
	from
	source : IN!"face::integration::UoPInstance" in MM (source.oclIsTypeOf(IN!"face::integration::UoPInstance"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes)).union(source.output->collect(it | thisModule.ReferenceToLink(it))).union(source.input->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__logical__Entity2Complex {
	from
	source : IN!"face::datamodel::logical::Entity" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Entity"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.specializes))
	)
}

rule CLface__uop__Connection2Complex {
	from
	source : IN!"face::uop::Connection" in MM (source.oclIsTypeOf(IN!"face::uop::Connection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__platform__CompositeTemplate2Complex {
	from
	source : IN!"face::datamodel::platform::CompositeTemplate" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CompositeTemplate"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.composition->collect(it | thisModule.ReferenceToLink(it))).add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__integration__TSNodeConnection2Complex {
	from
	source : IN!"face::integration::TSNodeConnection" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodeConnection"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.source)).add(thisModule.ReferenceToLink(source.destination))
	)
}

rule CLface__integration__IntegrationModel2Complex {
	from
	source : IN!"face::integration::IntegrationModel" in MM (source.oclIsTypeOf(IN!"face::integration::IntegrationModel"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.im->collect(it | thisModule.ReferenceToLink(it))).union(source.element->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__integration__TSNodePortBase2Complex {
	from
	source : IN!"face::integration::TSNodePortBase" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodePortBase"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

rule CLface__datamodel__logical__QueryComposition2Complex {
	from
	source : IN!"face::datamodel::logical::QueryComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::QueryComposition"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes)).add(thisModule.ReferenceToLink(source.type))
	)
}

rule CLface__traceability__ConnectionTraceabilitySet2Complex {
	from
	source : IN!"face::traceability::ConnectionTraceabilitySet" in MM (source.oclIsTypeOf(IN!"face::traceability::ConnectionTraceabilitySet"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.union(source.traceabilityPoint->collect(it | thisModule.ReferenceToLink(it))).union(source.connection->collect(it | thisModule.ReferenceToLink(it))).union(source.abstractConnection->collect(it | thisModule.ReferenceToLink(it)))
	)
}

rule CLface__datamodel__conceptual__PathNode2Complex {
	from
	source : IN!"face::datamodel::conceptual::PathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::PathNode"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.node))
	)
}

rule CLface__datamodel__platform__Long2Complex {
	from
	source : IN!"face::datamodel::platform::Long" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Long"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}.add(thisModule.ReferenceToLink(source.realizes))
	)
}

rule CLface__datamodel__logical__AbstractMeasurementSystem2Complex {
	from
	source : IN!"face::datamodel::logical::AbstractMeasurementSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::AbstractMeasurementSystem"))
	to
	prim : OUT!Complex (
		name <- source.toString(),
		primitives <- Set{}
	)
}

lazy rule face__datamodel__platform__ParticipantReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Participant" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Participant"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__UoPEndPointReferenceToLink {
	from
	source : IN!"face::integration::UoPEndPoint" in MM (source.oclIsTypeOf(IN!"face::integration::UoPEndPoint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__UnitReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Unit" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Unit"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__ComposableElementReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::ComposableElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::ComposableElement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__ElementReferenceToLink {
	from
	source : IN!"face::Element" in MM (source.oclIsTypeOf(IN!"face::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__BooleanReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Boolean" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Boolean"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__traceability__UoPTraceabilitySetReferenceToLink {
	from
	source : IN!"face::traceability::UoPTraceabilitySet" in MM (source.oclIsTypeOf(IN!"face::traceability::UoPTraceabilitySet"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__LongLongReferenceToLink {
	from
	source : IN!"face::datamodel::platform::LongLong" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::LongLong"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__UoPModelReferenceToLink {
	from
	source : IN!"face::uop::UoPModel" in MM (source.oclIsTypeOf(IN!"face::uop::UoPModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__traceability__TraceableElementReferenceToLink {
	from
	source : IN!"face::traceability::TraceableElement" in MM (source.oclIsTypeOf(IN!"face::traceability::TraceableElement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLArrayReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLArray" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLArray"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__LogicalDataModelReferenceToLink {
	from
	source : IN!"face::datamodel::LogicalDataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::LogicalDataModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__StandardMeasurementSystemReferenceToLink {
	from
	source : IN!"face::datamodel::logical::StandardMeasurementSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::StandardMeasurementSystem"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__PubSubConnectionReferenceToLink {
	from
	source : IN!"face::uop::PubSubConnection" in MM (source.oclIsTypeOf(IN!"face::uop::PubSubConnection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__BoundedStringReferenceToLink {
	from
	source : IN!"face::datamodel::platform::BoundedString" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::BoundedString"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ComposableElementReferenceToLink {
	from
	source : IN!"face::datamodel::platform::ComposableElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ComposableElement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ViewTransporterReferenceToLink {
	from
	source : IN!"face::integration::ViewTransporter" in MM (source.oclIsTypeOf(IN!"face::integration::ViewTransporter"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLBoundedStringReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLBoundedString" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLBoundedString"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__UoPInputEndPointReferenceToLink {
	from
	source : IN!"face::integration::UoPInputEndPoint" in MM (source.oclIsTypeOf(IN!"face::integration::UoPInputEndPoint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__EnumeratedReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Enumerated" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Enumerated"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TransportChannelReferenceToLink {
	from
	source : IN!"face::integration::TransportChannel" in MM (source.oclIsTypeOf(IN!"face::integration::TransportChannel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ViewTransformationReferenceToLink {
	from
	source : IN!"face::integration::ViewTransformation" in MM (source.oclIsTypeOf(IN!"face::integration::ViewTransformation"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CharArrayReferenceToLink {
	from
	source : IN!"face::datamodel::platform::CharArray" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CharArray"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__LifeCycleManagementPortReferenceToLink {
	from
	source : IN!"face::uop::LifeCycleManagementPort" in MM (source.oclIsTypeOf(IN!"face::uop::LifeCycleManagementPort"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CharacteristicReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Characteristic" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Characteristic"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CharacteristicPathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::CharacteristicPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CharacteristicPathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementConversionReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementConversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementConversion"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLStructReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLStruct" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLStruct"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__TemplateReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Template" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Template"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__traceability__TraceabilityPointReferenceToLink {
	from
	source : IN!"face::traceability::TraceabilityPoint" in MM (source.oclIsTypeOf(IN!"face::traceability::TraceabilityPoint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__EnumerationReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Enumeration" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Enumeration"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLTypeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLType"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__AssociationReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Association" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Association"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLUnsignedIntegerReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLUnsignedInteger" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLUnsignedInteger"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CharTypeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::CharType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CharType"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__LongDoubleReferenceToLink {
	from
	source : IN!"face::datamodel::platform::LongDouble" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::LongDouble"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ComposableElementReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ComposableElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ComposableElement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__IntegerReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Integer" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Integer"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__DataModelReferenceToLink {
	from
	source : IN!"face::datamodel::DataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::DataModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__ThreadReferenceToLink {
	from
	source : IN!"face::uop::Thread" in MM (source.oclIsTypeOf(IN!"face::uop::Thread"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__ConceptualDataModelReferenceToLink {
	from
	source : IN!"face::datamodel::ConceptualDataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::ConceptualDataModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__StringTypeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::StringType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::StringType"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__NaturalReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Natural" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Natural"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CharacterReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Character" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Character"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__EnumerationLabelReferenceToLink {
	from
	source : IN!"face::datamodel::logical::EnumerationLabel" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::EnumerationLabel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ValueTypeReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ValueType" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ValueType"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__PathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::logical::PathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::PathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementSystemAxisReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementSystemAxis" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementSystemAxis"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLRealReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLReal" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLReal"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ShortReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Short" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Short"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__QueryReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Query" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Query"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLCharacterArrayReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLCharacterArray" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLCharacterArray"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__RealConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::RealConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::RealConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ParticipantPathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::ParticipantPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ParticipantPathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__traceability__ElementReferenceToLink {
	from
	source : IN!"face::traceability::Element" in MM (source.oclIsTypeOf(IN!"face::traceability::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__AffineConversionReferenceToLink {
	from
	source : IN!"face::datamodel::logical::AffineConversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::AffineConversion"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ParticipantReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Participant" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Participant"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ViewSinkReferenceToLink {
	from
	source : IN!"face::integration::ViewSink" in MM (source.oclIsTypeOf(IN!"face::integration::ViewSink"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TSNodeInputPortReferenceToLink {
	from
	source : IN!"face::integration::TSNodeInputPort" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodeInputPort"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__PhysicalDataTypeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::PhysicalDataType" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::PhysicalDataType"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__RealRangeConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::RealRangeConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::RealRangeConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__ElementReferenceToLink {
	from
	source : IN!"face::datamodel::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__SingleInstanceMessageConnectionReferenceToLink {
	from
	source : IN!"face::uop::SingleInstanceMessageConnection" in MM (source.oclIsTypeOf(IN!"face::uop::SingleInstanceMessageConnection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__ElementReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__ElementReferenceToLink {
	from
	source : IN!"face::uop::Element" in MM (source.oclIsTypeOf(IN!"face::uop::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__TemplateCompositionReferenceToLink {
	from
	source : IN!"face::datamodel::platform::TemplateComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::TemplateComposition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__IntegerRangeConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::IntegerRangeConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::IntegerRangeConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLSequenceReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLSequence" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLSequence"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__NumericReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Numeric" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Numeric"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__StringReferenceToLink {
	from
	source : IN!"face::datamodel::logical::String" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::String"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__CompositeQueryReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::CompositeQuery" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::CompositeQuery"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__QueryReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Query" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Query"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__ObservableReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Observable" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Observable"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementSystemConversionReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementSystemConversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementSystemConversion"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ViewReferenceToLink {
	from
	source : IN!"face::datamodel::logical::View" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::View"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__FixedReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Fixed" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Fixed"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLCompositionReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLComposition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ViewFilterReferenceToLink {
	from
	source : IN!"face::integration::ViewFilter" in MM (source.oclIsTypeOf(IN!"face::integration::ViewFilter"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__traceability__TraceabilityModelReferenceToLink {
	from
	source : IN!"face::traceability::TraceabilityModel" in MM (source.oclIsTypeOf(IN!"face::traceability::TraceabilityModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CompositionReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Composition" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Composition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__RAMMemoryRequirementsReferenceToLink {
	from
	source : IN!"face::uop::RAMMemoryRequirements" in MM (source.oclIsTypeOf(IN!"face::uop::RAMMemoryRequirements"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__IntegrationContextReferenceToLink {
	from
	source : IN!"face::integration::IntegrationContext" in MM (source.oclIsTypeOf(IN!"face::integration::IntegrationContext"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__FloatReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Float" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Float"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__AbstractConnectionReferenceToLink {
	from
	source : IN!"face::uop::AbstractConnection" in MM (source.oclIsTypeOf(IN!"face::uop::AbstractConnection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__DomainReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Domain" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Domain"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TSNodePortReferenceToLink {
	from
	source : IN!"face::integration::TSNodePort" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodePort"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__ArchitectureModelReferenceToLink {
	from
	source : IN!"face::ArchitectureModel" in MM (source.oclIsTypeOf(IN!"face::ArchitectureModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__RealReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Real" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Real"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__UnitOfPortabilityReferenceToLink {
	from
	source : IN!"face::uop::UnitOfPortability" in MM (source.oclIsTypeOf(IN!"face::uop::UnitOfPortability"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__PlatformDataModelReferenceToLink {
	from
	source : IN!"face::datamodel::PlatformDataModel" in MM (source.oclIsTypeOf(IN!"face::datamodel::PlatformDataModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__QueryCompositionReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::QueryComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::QueryComposition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__BasisEntityReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::BasisEntity" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::BasisEntity"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__AbstractMeasurementReferenceToLink {
	from
	source : IN!"face::datamodel::logical::AbstractMeasurement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::AbstractMeasurement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__PathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::platform::PathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::PathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__QueuingConnectionReferenceToLink {
	from
	source : IN!"face::uop::QueuingConnection" in MM (source.oclIsTypeOf(IN!"face::uop::QueuingConnection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__ClientServerConnectionReferenceToLink {
	from
	source : IN!"face::uop::ClientServerConnection" in MM (source.oclIsTypeOf(IN!"face::uop::ClientServerConnection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__OctetReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Octet" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Octet"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__DoubleReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Double" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Double"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__QueryReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Query" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Query"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ElementReferenceToLink {
	from
	source : IN!"face::integration::Element" in MM (source.oclIsTypeOf(IN!"face::integration::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__NonNegativeRealReferenceToLink {
	from
	source : IN!"face::datamodel::logical::NonNegativeReal" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::NonNegativeReal"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementAttributeReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementAttribute" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementAttribute"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__AbstractUoPReferenceToLink {
	from
	source : IN!"face::uop::AbstractUoP" in MM (source.oclIsTypeOf(IN!"face::uop::AbstractUoP"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__AssociationReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Association" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Association"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__EntityReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Entity" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Entity"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ViewAggregationReferenceToLink {
	from
	source : IN!"face::integration::ViewAggregation" in MM (source.oclIsTypeOf(IN!"face::integration::ViewAggregation"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__RegularExpressionConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::RegularExpressionConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::RegularExpressionConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ParticipantPathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ParticipantPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ParticipantPathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ElementReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__ViewReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::View" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::View"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementAxisReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementAxis" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementAxis"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CoordinateSystemAxisReferenceToLink {
	from
	source : IN!"face::datamodel::logical::CoordinateSystemAxis" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CoordinateSystemAxis"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__FixedLengthStringConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::FixedLengthStringConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::FixedLengthStringConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TransportNodeReferenceToLink {
	from
	source : IN!"face::integration::TransportNode" in MM (source.oclIsTypeOf(IN!"face::integration::TransportNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CoordinateSystemReferenceToLink {
	from
	source : IN!"face::datamodel::logical::CoordinateSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CoordinateSystem"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLPrimitiveReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLPrimitive" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLPrimitive"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ConvertibleElementReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ConvertibleElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ConvertibleElement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ValueTypeUnitReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ValueTypeUnit" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ValueTypeUnit"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ElementReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Element" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Element"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__ComponentFrameworkReferenceToLink {
	from
	source : IN!"face::uop::ComponentFramework" in MM (source.oclIsTypeOf(IN!"face::uop::ComponentFramework"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__StringConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::StringConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::StringConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CharacteristicPathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::logical::CharacteristicPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CharacteristicPathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementSystemReferenceToLink {
	from
	source : IN!"face::datamodel::logical::MeasurementSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::MeasurementSystem"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__AssociationReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Association" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Association"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__BasisElementReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::BasisElement" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::BasisElement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ULongLongReferenceToLink {
	from
	source : IN!"face::datamodel::platform::ULongLong" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ULongLong"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CompositionReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Composition" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Composition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__CompositeQueryReferenceToLink {
	from
	source : IN!"face::datamodel::logical::CompositeQuery" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::CompositeQuery"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__SupportingComponentReferenceToLink {
	from
	source : IN!"face::uop::SupportingComponent" in MM (source.oclIsTypeOf(IN!"face::uop::SupportingComponent"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLNumberReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLNumber" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLNumber"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Constraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Constraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__CharacteristicReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Characteristic" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Characteristic"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TSNodeOutputPortReferenceToLink {
	from
	source : IN!"face::integration::TSNodeOutputPort" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodeOutputPort"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__MeasurementReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Measurement" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Measurement"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ConversionReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Conversion" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Conversion"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ReferencePointReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ReferencePoint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ReferencePoint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__IntegerConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::IntegerConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::IntegerConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__PortableComponentReferenceToLink {
	from
	source : IN!"face::uop::PortableComponent" in MM (source.oclIsTypeOf(IN!"face::uop::PortableComponent"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ULongReferenceToLink {
	from
	source : IN!"face::datamodel::platform::ULong" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::ULong"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__ReferencePointPartReferenceToLink {
	from
	source : IN!"face::datamodel::logical::ReferencePointPart" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::ReferencePointPart"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__StringReferenceToLink {
	from
	source : IN!"face::datamodel::platform::String" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::String"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__EntityReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Entity" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Entity"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__LandmarkReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Landmark" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Landmark"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLUnboundedStringReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLUnboundedString" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLUnboundedString"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__EnumerationConstraintReferenceToLink {
	from
	source : IN!"face::datamodel::logical::EnumerationConstraint" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::EnumerationConstraint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__ViewSourceReferenceToLink {
	from
	source : IN!"face::integration::ViewSource" in MM (source.oclIsTypeOf(IN!"face::integration::ViewSource"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__IDLIntegerReferenceToLink {
	from
	source : IN!"face::datamodel::platform::IDLInteger" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::IDLInteger"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__PlatformSpecificComponentReferenceToLink {
	from
	source : IN!"face::uop::PlatformSpecificComponent" in MM (source.oclIsTypeOf(IN!"face::uop::PlatformSpecificComponent"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CharacteristicReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Characteristic" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Characteristic"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CharReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Char" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Char"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__UShortReferenceToLink {
	from
	source : IN!"face::datamodel::platform::UShort" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::UShort"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__UoPOutputEndPointReferenceToLink {
	from
	source : IN!"face::integration::UoPOutputEndPoint" in MM (source.oclIsTypeOf(IN!"face::integration::UoPOutputEndPoint"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__LanguageRunTimeReferenceToLink {
	from
	source : IN!"face::uop::LanguageRunTime" in MM (source.oclIsTypeOf(IN!"face::uop::LanguageRunTime"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__CharacteristicPathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::CharacteristicPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::CharacteristicPathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__BooleanReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Boolean" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Boolean"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__ParticipantPathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::ParticipantPathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::ParticipantPathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__ViewReferenceToLink {
	from
	source : IN!"face::datamodel::platform::View" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::View"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__CompositionReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Composition" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Composition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__ParticipantReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::Participant" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::Participant"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__UoPInstanceReferenceToLink {
	from
	source : IN!"face::integration::UoPInstance" in MM (source.oclIsTypeOf(IN!"face::integration::UoPInstance"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__EntityReferenceToLink {
	from
	source : IN!"face::datamodel::logical::Entity" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::Entity"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__uop__ConnectionReferenceToLink {
	from
	source : IN!"face::uop::Connection" in MM (source.oclIsTypeOf(IN!"face::uop::Connection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__CompositeTemplateReferenceToLink {
	from
	source : IN!"face::datamodel::platform::CompositeTemplate" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::CompositeTemplate"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TSNodeConnectionReferenceToLink {
	from
	source : IN!"face::integration::TSNodeConnection" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodeConnection"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__IntegrationModelReferenceToLink {
	from
	source : IN!"face::integration::IntegrationModel" in MM (source.oclIsTypeOf(IN!"face::integration::IntegrationModel"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__integration__TSNodePortBaseReferenceToLink {
	from
	source : IN!"face::integration::TSNodePortBase" in MM (source.oclIsTypeOf(IN!"face::integration::TSNodePortBase"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__QueryCompositionReferenceToLink {
	from
	source : IN!"face::datamodel::logical::QueryComposition" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::QueryComposition"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__traceability__ConnectionTraceabilitySetReferenceToLink {
	from
	source : IN!"face::traceability::ConnectionTraceabilitySet" in MM (source.oclIsTypeOf(IN!"face::traceability::ConnectionTraceabilitySet"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__conceptual__PathNodeReferenceToLink {
	from
	source : IN!"face::datamodel::conceptual::PathNode" in MM (source.oclIsTypeOf(IN!"face::datamodel::conceptual::PathNode"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__platform__LongReferenceToLink {
	from
	source : IN!"face::datamodel::platform::Long" in MM (source.oclIsTypeOf(IN!"face::datamodel::platform::Long"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}

lazy rule face__datamodel__logical__AbstractMeasurementSystemReferenceToLink {
	from
	source : IN!"face::datamodel::logical::AbstractMeasurementSystem" in MM (source.oclIsTypeOf(IN!"face::datamodel::logical::AbstractMeasurementSystem"))
	to
	link : OUT!Link (
		referenceTo <- source
	)
}