plugins/org.eclipse.gmf.bridge/transforms/Mappings.qvto - gerrit/gmf-tooling/org.eclipse.gmf-tooling - Git at Google

 /**
  * Copyright (c) 2009, 2011, 2012 Borland Software Corporation & others
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Artem Tikhomirov (Borland) - initial API and implementation
  *    Guillaume Hillairet (Montages A.G.)
  */
 library Mappings;

 import Utils;
 import ModelFacets;
 import Palette;
 import Viewmaps;
 import ModeledViewmaps;
 import Identity;
 import Behaviours;

 modeltype GMFMAP uses mappings('http://www.eclipse.org/gmf/2006/mappings');
 modeltype GMFTOOL uses tooldef('http://www.eclipse.org/gmf/2005/ToolDefinition');
 modeltype GMFGEN uses gmfgen('http://www.eclipse.org/gmf/2009/GenModel');
 modeltype GMFGRAPH uses gmfgraph('http://www.eclipse.org/gmf/2006/GraphicalDefinition');
 modeltype ECORE uses ecore('http://www.eclipse.org/emf/2002/Ecore');
 modeltype GENMODEL uses genmodel('http://www.eclipse.org/emf/2002/GenModel');

 --
 --	Mapping
 --

 property genEditorGenerator : GMFGEN::GenEditorGenerator = null;

 mapping GMFMAP::Mapping::structure() : GMFGEN::GenEditorGenerator {
 	init {
 		result := object GMFGEN::GenEditorGenerator {
 			diagram := self.diagram.map structure();
 		}
 	}
 	genEditorGenerator := result;

 	childReferences := self.getChildReferences();
 	self.nodes->map structure();
 	diagram.links := self.links->map structure();

 	diagram.getAllNodes()->forEach(n) { setupElementType(n) };
 	diagram.links->forEach(l) { setupElementType(l) };

 	if self.expressionsByLanguages()->notEmpty() then
 		expressionProviders := self.map createProviderContainer()
 	endif;
 }

 mapping GMFMAP::Mapping::createProviderContainer(): GMFGEN::GenExpressionProviderContainer {
 	self.expressionsByLanguages()->forEach(e) {
 		providers += e.map createExpressionProvider()
 	}
 }

 mapping GMFMAP::CanvasMapping::structure() : GMFGEN::GenDiagram {
 	init {
 		result := object GenDiagram {
 			viewmap := self.viewmap();
 			domainDiagramElement := self.domainMetaElement.findGenClass();
 			iconProviderPriority := GMFGEN::ProviderPriority::Low;
 			validationProviderPriority := GMFGEN::ProviderPriority::Low;
 		}
 	}

 	result.visualID := result.visualID();

 	if result.domainDiagramElement.oclIsUndefined() then
 		result.elementType := object GMFGEN::NotationType {}
 	else
 		result.elementType := result.domainDiagramElement.getOrCreateRuntimeMetamodelType()
 	endif;
 }

 --
 -- TopLevelNode
 --

 mapping GMFMAP::TopNodeReference::structure() : GMFGEN::GenTopLevelNode {
 	init {
 		result := object GenTopLevelNode {
 			modelFacet := self.createModelFacet();
 			viewmap := self.viewmap();
 		}
 	}
 	genEditorGenerator.diagram.topLevelNodes += result;
 	result.visualID := result.visualID();
 	self.child.tool.map paletteEntry().oclAsType(ToolEntry).genNodes += result;

 	self.child.map abstractStructure(result);

 	labels += self.child.labelMappings->map createNodeLabel(self, result);
 	behaviour += self.child.relatedDiagrams.handleRelatedDiagram(self.child);
 	behaviour += self.child.visualEffects->map createVisualEffects(result, self.child.diagramNode);
 }

 --
 --
 --
 mapping GMFMAP::NodeMapping::abstractStructure(inout genNode: GMFGEN::GenNode) {
 	var mapOfCompartments : Dict(CompartmentMapping, GenCompartment) = Dict{};
 	self.compartments->forEach(c) {
 		var childCompartment := object GMFGEN::GenCompartment {
 			title := c.compartment.name;
 			canCollapse := c.compartment.collapsible;
 			needsTitle := c.compartment.needsTitle;
 			viewmap := c.viewmap();
 		};
 		mapOfCompartments->put(c, childCompartment);
 		genEditorGenerator.diagram.compartments += childCompartment;
 		genNode.compartments += childCompartment;
 		childCompartment.node := genNode;
 		childCompartment.visualID := childCompartment.visualID();
 	};

 	self.children->forEach(childNodeRef) {
 		var compartmentMapping := childNodeRef.compartment;
 		var genChildContainer : GenChildContainer = null;
 		if not compartmentMapping.oclIsUndefined() and not mapOfCompartments->get(compartmentMapping).oclIsUndefined() then
 			genChildContainer := mapOfCompartments->get(compartmentMapping)
 		else
 			 genChildContainer := genNode
 		endif;

 		var childNodeMapping := childNodeRef.child;
 		var node := childNodeRef.findProcessableChildReference();
 		var childNode := node.map structure(childNodeMapping);
 		if genChildContainer.oclIsKindOf(GenCompartment) and childNodeMapping.children->size() > 0 then
 			genChildContainer.oclAsType(GenCompartment).listLayout := false
 		endif;
 		genChildContainer.childNodes += childNode;
 	};
 }

 --
 -- GenChildNode
 --
 abstract mapping GMFMAP::ChildReference::abstractStructure(nodeMapping: GMFMAP::NodeMapping): GMFGEN::GenChildNode {
 	modelFacet := self.createModelFacet();
 	viewmap := self.viewmap(nodeMapping);

 	self.child.tool.map paletteEntry().oclAsType(ToolEntry).genNodes += result;
 }

 mapping GMFMAP::ChildReference::structure(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildNode
 disjuncts
 	GMFMAP::ChildReference::createGenChildLabelNode,
 	GMFMAP::ChildReference::createGenChildSideAffixedNode,
 	GMFMAP::ChildReference::createGenChildNode
 {}

 mapping GMFMAP::ChildReference::createGenChildLabelNode(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildLabelNode
 inherits GMFMAP::ChildReference::abstractStructure
 when {
 	nodeMapping.isPureLabelNode()
 }
 {
 	init {
 		result := object GMFGEN::GenChildLabelNode {}
 	}
 	genEditorGenerator.diagram.childNodes += result;
 	result.visualID := result.visualID();

 	var soleLabel := nodeMapping.labelMappings->first();
 	labelModelFacet := soleLabel.map createLabelModelFacet(self);
 	labelReadOnly := soleLabel.readOnly;
 	labelElementIcon := soleLabel.diagramLabel.elementIcon;
 }

 mapping GMFMAP::ChildReference::createGenChildSideAffixedNode(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildSideAffixedNode
 inherits GMFMAP::ChildReference::abstractStructure
 when {
 	nodeMapping.diagramNode.affixedParentSide <> GMFGRAPH::Direction::NONE
 }
 {
 	init {
 		result := object GMFGEN::GenChildSideAffixedNode {}
 	}

 	genEditorGenerator.diagram.childNodes += result;
 	result.visualID := result.visualID();
 	self.child.map abstractStructure(result);

 	preferredSideName := nodeMapping.diagramNode.getAffixedSideAsPositionConstantsName();
 	labels += nodeMapping.labelMappings->map createNodeLabel(self, result);
 	behaviour += nodeMapping.relatedDiagrams.handleRelatedDiagram(nodeMapping);
 	behaviour +=  nodeMapping.visualEffects->map createVisualEffects(result, nodeMapping.diagramNode);
 }

 mapping GMFMAP::ChildReference::createGenChildNode(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildNode
 inherits GMFMAP::ChildReference::abstractStructure
 {
 	init {
 		result := object GMFGEN::GenChildNode {}
 	}
 	genEditorGenerator.diagram.childNodes += result;
 	result.visualID := result.visualID();
 	self.child.map abstractStructure(result);

 	nodeMapping.labelMappings->map createNodeLabel(self, result);
 	behaviour += nodeMapping.relatedDiagrams.handleRelatedDiagram(nodeMapping);
 	behaviour +=  nodeMapping.visualEffects->map createVisualEffects(result, nodeMapping.diagramNode);
 }

 --
 -- NodeLabel
 --

 mapping GMFMAP::LabelMapping::createNodeLabel(node: NodeReference, inout genNode: GMFGEN::GenNode) : GMFGEN::GenNodeLabel {
 	init {
 		if self.diagramLabel.external then
 			result := object GenExternalNodeLabel {}
 		else
 			result := object GenNodeLabel {}
 		endif
 	}

 	result.viewmap := self.viewmap();
 	result.modelFacet := self.map createLabelModelFacet(node);
 	result.readOnly := self.readOnly;
 	result.elementIcon := self.diagramLabel.elementIcon;
 	genNode.labels += result;
 	result.visualID := result.visualID();
 }

 --
 --	GenLink
 --
 mapping GMFMAP::LinkMapping::structure() : GMFGEN::GenLink
 when {
 	not self.diagramLink.oclIsUndefined() and
 	not self.linkMetaFeature.oclIsUndefined()
 }{
 	init {
 		result := object GMFGEN::GenLink {
 			-- model facet
 			if not (self.domainMetaElement.oclIsUndefined() and self.linkMetaFeature.oclIsUndefined()) then
 				modelFacet := self.map createModelFacet()
 			endif;

 			viewmap := self.viewmap();
 		}
 	}

 	genEditorGenerator.diagram.links += result;
 	result.visualID := result.visualID();

 	-- labels
 	self.labelMappings->map structure(self, result);

 	self.tool.map paletteEntry().oclAsType(ToolEntry).genLinks += result;
 	result.creationConstraints := self.creationConstraints.map structure();

 	behaviour += self.visualEffects->map createVisualEffects(result, self.diagramLink);
 }

 mapping LabelMapping::structure(link: GMFMAP::LinkMapping, inout genLink: GMFGEN::GenLink): GenLinkLabel {
 	init {
 		result := object GMFGEN::GenLinkLabel {
 			readOnly := self.readOnly;
 			elementIcon := self.diagramLabel.elementIcon;
 			modelFacet := self.map createLabelModelFacet(link);
 			viewmap := self.viewmap();

 			var alignmentFacet := self.diagramLabel.findAlignmentFacet();
 			if not alignmentFacet.oclIsUndefined() then
 				alignment := switch  {
 					case (alignmentFacet.alignment = GMFGRAPH::Alignment::BEGINNING) LinkLabelAlignment::SOURCE;
 					case (alignmentFacet.alignment = GMFGRAPH::Alignment::CENTER) LinkLabelAlignment::MIDDLE;
 					case (alignmentFacet.alignment = GMFGRAPH::Alignment::END) LinkLabelAlignment::TARGET;
 					else LinkLabelAlignment::MIDDLE;
 				}
 			endif;
 		}
 	}

 	genLink.labels += result;
 	result.visualID := result.visualID()
 }


 -- XXX ElementType as return value, disjunct?
 mapping GENMODEL::GenClass::gmfRuntimeMetamodelType() : GMFGEN::MetamodelType {}

 --
 --	Helpers
 --

 query GENMODEL::GenClass::getOrCreateRuntimeMetamodelType() : GMFGEN::ElementType {
 	var mmt = self.resolveoneIn(GENMODEL::GenClass::gmfRuntimeMetamodelType, GMFGEN::MetamodelType);
 	if mmt.oclIsUndefined() then
 		return self.map gmfRuntimeMetamodelType()
 	endif;
 	return object GMFGEN::SpecializationType { metamodelType := mmt }
 }

 -- XXX review - Specialization type is created again and again - why not reuse it?
 -- static, for some reasons, helpers couldn't specify 'inout' for context element
 -- XXX, actually, don't need GenNode here, GenClass should be sufficient
 helper setupElementType(inout genNode : GMFGEN::GenNode) {
 	if genNode.modelFacet.oclIsUndefined() then genNode.elementType := object GMFGEN::NotationType {}
 	else genNode.elementType := genNode.modelFacet.metaClass.getOrCreateRuntimeMetamodelType() endif;
 	return;
 }

 helper setupElementType(inout genLink : GMFGEN::GenLink) {
 	if genLink.modelFacet.oclIsUndefined() then
 		genLink.elementType := object GMFGEN::NotationType {}
 	else
 		if genLink.modelFacet.oclIsKindOf(GMFGEN::TypeModelFacet) then
 			genLink.elementType := genLink.modelFacet.oclAsType(GMFGEN::TypeModelFacet).metaClass.getOrCreateRuntimeMetamodelType()
 		else { -- ref-based link; specialize null
 			genLink.elementType := object GMFGEN::SpecializationType {};
 		--	genLink.elementType.displayName := genLink.modelFacet.oclAsType(FeatureLinkModelFacet).metaFeature.ecoreFeature.name.firstToUpper();
 		} endif
 	endif;
 	return;
 }

 helper GMFMAP::CanvasMapping::viewmap(): Viewmap =
 	if useModeledViewmaps then
 		object ModeledViewmap {
 			figureModel := self.diagramCanvas.oclAsType(EObject);
 		}
 	else
 		self.diagramCanvas.map Viewmaps::viewmap()
 	endif;

 helper GMFMAP::TopNodeReference::viewmap(): Viewmap =
 	if useModeledViewmaps then
 		self.child.diagramNode.ModeledViewmaps::viewmap()
 	else
 		self.child.diagramNode.Viewmaps::viewmap()
 	endif;

 helper GMFMAP::ChildReference::viewmap(_mapping: NodeMapping): Viewmap =
 	if useModeledViewmaps then
 		self.child.diagramNode.ModeledViewmaps::viewmap()
 	else
 		self.Viewmaps::viewmap(_mapping)
 	endif;

 helper GMFMAP::LinkMapping::viewmap(): Viewmap =
 	if useModeledViewmaps then
 		self.diagramLink.ModeledViewmaps::viewmap()
 	else
 		self.diagramLink.Viewmaps::viewmap()
 	endif;

 helper GMFMAP::LabelMapping::viewmap(): Viewmap =
 	if useModeledViewmaps then
 		self.diagramLabel.ModeledViewmaps::viewmap()
 	else
 		self.diagramLabel.Viewmaps::viewmap()
 	endif;

 helper GMFMAP::CompartmentMapping::viewmap(): Viewmap =
 	if useModeledViewmaps then
 		self.compartment.ModeledViewmaps::viewmap()
 	else
 		self.compartment.Viewmaps::viewmap()
 	endif;

 --
 --	Queries
 --

 query GMFMAP::Mapping::expressionsByLanguages(): Sequence(ValueExpression) =
 	GMFMAP::ValueExpression.allInstances()->iterate(it; res: Sequence(ValueExpression) = Sequence{} |
 		if res->exists(e | e.language = it.language) then res else res->including(it) endif
 	);

 query GMFGRAPH::Node::getAffixedSideAsPositionConstantsName() : String =
 	switch {
 		case (self.affixedParentSide = GMFGRAPH::Direction::NONE) assert (false) with log('DiagramNode is not side-affixed', self);
 		case (self.affixedParentSide = GMFGRAPH::Direction::EAST) return 'EAST';
 		case (self.affixedParentSide = GMFGRAPH::Direction::WEST) return 'WEST';
 		case (self.affixedParentSide = GMFGRAPH::Direction::NORTH) return 'NORTH';
 		case (self.affixedParentSide = GMFGRAPH::Direction::SOUTH) return 'SOUTH';
 		case (self.affixedParentSide = GMFGRAPH::Direction::NSEW) return 'NONE'; -- any side
 		else return 'NONE'; -- any side
 	};

 query DiagramElement::findAlignmentFacet(): AlignmentFacet =
 	self.facets->selectOne(e | e.oclIsKindOf(AlignmentFacet)).oclAsType(AlignmentFacet);
	/**
	* Copyright (c) 2009, 2011, 2012 Borland Software Corporation & others
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Artem Tikhomirov (Borland) - initial API and implementation
	* Guillaume Hillairet (Montages A.G.)
	*/
	library Mappings;

	import Utils;
	import ModelFacets;
	import Palette;
	import Viewmaps;
	import ModeledViewmaps;
	import Identity;
	import Behaviours;

	modeltype GMFMAP uses mappings('http://www.eclipse.org/gmf/2006/mappings');
	modeltype GMFTOOL uses tooldef('http://www.eclipse.org/gmf/2005/ToolDefinition');
	modeltype GMFGEN uses gmfgen('http://www.eclipse.org/gmf/2009/GenModel');
	modeltype GMFGRAPH uses gmfgraph('http://www.eclipse.org/gmf/2006/GraphicalDefinition');
	modeltype ECORE uses ecore('http://www.eclipse.org/emf/2002/Ecore');
	modeltype GENMODEL uses genmodel('http://www.eclipse.org/emf/2002/GenModel');

	--
	-- Mapping
	--

	property genEditorGenerator : GMFGEN::GenEditorGenerator = null;

	mapping GMFMAP::Mapping::structure() : GMFGEN::GenEditorGenerator {
	init {
	result := object GMFGEN::GenEditorGenerator {
	diagram := self.diagram.map structure();
	}
	}
	genEditorGenerator := result;

	childReferences := self.getChildReferences();
	self.nodes->map structure();
	diagram.links := self.links->map structure();

	diagram.getAllNodes()->forEach(n) { setupElementType(n) };
	diagram.links->forEach(l) { setupElementType(l) };

	if self.expressionsByLanguages()->notEmpty() then
	expressionProviders := self.map createProviderContainer()
	endif;
	}

	mapping GMFMAP::Mapping::createProviderContainer(): GMFGEN::GenExpressionProviderContainer {
	self.expressionsByLanguages()->forEach(e) {
	providers += e.map createExpressionProvider()
	}
	}

	mapping GMFMAP::CanvasMapping::structure() : GMFGEN::GenDiagram {
	init {
	result := object GenDiagram {
	viewmap := self.viewmap();
	domainDiagramElement := self.domainMetaElement.findGenClass();
	iconProviderPriority := GMFGEN::ProviderPriority::Low;
	validationProviderPriority := GMFGEN::ProviderPriority::Low;
	}
	}

	result.visualID := result.visualID();

	if result.domainDiagramElement.oclIsUndefined() then
	result.elementType := object GMFGEN::NotationType {}
	else
	result.elementType := result.domainDiagramElement.getOrCreateRuntimeMetamodelType()
	endif;
	}

	--
	-- TopLevelNode
	--

	mapping GMFMAP::TopNodeReference::structure() : GMFGEN::GenTopLevelNode {
	init {
	result := object GenTopLevelNode {
	modelFacet := self.createModelFacet();
	viewmap := self.viewmap();
	}
	}
	genEditorGenerator.diagram.topLevelNodes += result;
	result.visualID := result.visualID();
	self.child.tool.map paletteEntry().oclAsType(ToolEntry).genNodes += result;

	self.child.map abstractStructure(result);

	labels += self.child.labelMappings->map createNodeLabel(self, result);
	behaviour += self.child.relatedDiagrams.handleRelatedDiagram(self.child);
	behaviour += self.child.visualEffects->map createVisualEffects(result, self.child.diagramNode);
	}

	--
	--
	--
	mapping GMFMAP::NodeMapping::abstractStructure(inout genNode: GMFGEN::GenNode) {
	var mapOfCompartments : Dict(CompartmentMapping, GenCompartment) = Dict{};
	self.compartments->forEach(c) {
	var childCompartment := object GMFGEN::GenCompartment {
	title := c.compartment.name;
	canCollapse := c.compartment.collapsible;
	needsTitle := c.compartment.needsTitle;
	viewmap := c.viewmap();
	};
	mapOfCompartments->put(c, childCompartment);
	genEditorGenerator.diagram.compartments += childCompartment;
	genNode.compartments += childCompartment;
	childCompartment.node := genNode;
	childCompartment.visualID := childCompartment.visualID();
	};

	self.children->forEach(childNodeRef) {
	var compartmentMapping := childNodeRef.compartment;
	var genChildContainer : GenChildContainer = null;
	if not compartmentMapping.oclIsUndefined() and not mapOfCompartments->get(compartmentMapping).oclIsUndefined() then
	genChildContainer := mapOfCompartments->get(compartmentMapping)
	else
	genChildContainer := genNode
	endif;

	var childNodeMapping := childNodeRef.child;
	var node := childNodeRef.findProcessableChildReference();
	var childNode := node.map structure(childNodeMapping);
	if genChildContainer.oclIsKindOf(GenCompartment) and childNodeMapping.children->size() > 0 then
	genChildContainer.oclAsType(GenCompartment).listLayout := false
	endif;
	genChildContainer.childNodes += childNode;
	};
	}

	--
	-- GenChildNode
	--
	abstract mapping GMFMAP::ChildReference::abstractStructure(nodeMapping: GMFMAP::NodeMapping): GMFGEN::GenChildNode {
	modelFacet := self.createModelFacet();
	viewmap := self.viewmap(nodeMapping);

	self.child.tool.map paletteEntry().oclAsType(ToolEntry).genNodes += result;
	}

	mapping GMFMAP::ChildReference::structure(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildNode
	disjuncts
	GMFMAP::ChildReference::createGenChildLabelNode,
	GMFMAP::ChildReference::createGenChildSideAffixedNode,
	GMFMAP::ChildReference::createGenChildNode
	{}

	mapping GMFMAP::ChildReference::createGenChildLabelNode(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildLabelNode
	inherits GMFMAP::ChildReference::abstractStructure
	when {
	nodeMapping.isPureLabelNode()
	}
	{
	init {
	result := object GMFGEN::GenChildLabelNode {}
	}
	genEditorGenerator.diagram.childNodes += result;
	result.visualID := result.visualID();

	var soleLabel := nodeMapping.labelMappings->first();
	labelModelFacet := soleLabel.map createLabelModelFacet(self);
	labelReadOnly := soleLabel.readOnly;
	labelElementIcon := soleLabel.diagramLabel.elementIcon;
	}

	mapping GMFMAP::ChildReference::createGenChildSideAffixedNode(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildSideAffixedNode
	inherits GMFMAP::ChildReference::abstractStructure
	when {
	nodeMapping.diagramNode.affixedParentSide <> GMFGRAPH::Direction::NONE
	}
	{
	init {
	result := object GMFGEN::GenChildSideAffixedNode {}
	}

	genEditorGenerator.diagram.childNodes += result;
	result.visualID := result.visualID();
	self.child.map abstractStructure(result);

	preferredSideName := nodeMapping.diagramNode.getAffixedSideAsPositionConstantsName();
	labels += nodeMapping.labelMappings->map createNodeLabel(self, result);
	behaviour += nodeMapping.relatedDiagrams.handleRelatedDiagram(nodeMapping);
	behaviour += nodeMapping.visualEffects->map createVisualEffects(result, nodeMapping.diagramNode);
	}

	mapping GMFMAP::ChildReference::createGenChildNode(nodeMapping: GMFMAP::NodeMapping) : GMFGEN::GenChildNode
	inherits GMFMAP::ChildReference::abstractStructure
	{
	init {
	result := object GMFGEN::GenChildNode {}
	}
	genEditorGenerator.diagram.childNodes += result;
	result.visualID := result.visualID();
	self.child.map abstractStructure(result);

	nodeMapping.labelMappings->map createNodeLabel(self, result);
	behaviour += nodeMapping.relatedDiagrams.handleRelatedDiagram(nodeMapping);
	behaviour += nodeMapping.visualEffects->map createVisualEffects(result, nodeMapping.diagramNode);
	}

	--
	-- NodeLabel
	--

	mapping GMFMAP::LabelMapping::createNodeLabel(node: NodeReference, inout genNode: GMFGEN::GenNode) : GMFGEN::GenNodeLabel {
	init {
	if self.diagramLabel.external then
	result := object GenExternalNodeLabel {}
	else
	result := object GenNodeLabel {}
	endif
	}

	result.viewmap := self.viewmap();
	result.modelFacet := self.map createLabelModelFacet(node);
	result.readOnly := self.readOnly;
	result.elementIcon := self.diagramLabel.elementIcon;
	genNode.labels += result;
	result.visualID := result.visualID();
	}

	--
	-- GenLink
	--
	mapping GMFMAP::LinkMapping::structure() : GMFGEN::GenLink
	when {
	not self.diagramLink.oclIsUndefined() and
	not self.linkMetaFeature.oclIsUndefined()
	}{
	init {
	result := object GMFGEN::GenLink {
	-- model facet
	if not (self.domainMetaElement.oclIsUndefined() and self.linkMetaFeature.oclIsUndefined()) then
	modelFacet := self.map createModelFacet()
	endif;

	viewmap := self.viewmap();
	}
	}

	genEditorGenerator.diagram.links += result;
	result.visualID := result.visualID();

	-- labels
	self.labelMappings->map structure(self, result);

	self.tool.map paletteEntry().oclAsType(ToolEntry).genLinks += result;
	result.creationConstraints := self.creationConstraints.map structure();

	behaviour += self.visualEffects->map createVisualEffects(result, self.diagramLink);
	}

	mapping LabelMapping::structure(link: GMFMAP::LinkMapping, inout genLink: GMFGEN::GenLink): GenLinkLabel {
	init {
	result := object GMFGEN::GenLinkLabel {
	readOnly := self.readOnly;
	elementIcon := self.diagramLabel.elementIcon;
	modelFacet := self.map createLabelModelFacet(link);
	viewmap := self.viewmap();

	var alignmentFacet := self.diagramLabel.findAlignmentFacet();
	if not alignmentFacet.oclIsUndefined() then
	alignment := switch {
	case (alignmentFacet.alignment = GMFGRAPH::Alignment::BEGINNING) LinkLabelAlignment::SOURCE;
	case (alignmentFacet.alignment = GMFGRAPH::Alignment::CENTER) LinkLabelAlignment::MIDDLE;
	case (alignmentFacet.alignment = GMFGRAPH::Alignment::END) LinkLabelAlignment::TARGET;
	else LinkLabelAlignment::MIDDLE;
	}
	endif;
	}
	}

	genLink.labels += result;
	result.visualID := result.visualID()
	}


	-- XXX ElementType as return value, disjunct?
	mapping GENMODEL::GenClass::gmfRuntimeMetamodelType() : GMFGEN::MetamodelType {}

	--
	-- Helpers
	--

	query GENMODEL::GenClass::getOrCreateRuntimeMetamodelType() : GMFGEN::ElementType {
	var mmt = self.resolveoneIn(GENMODEL::GenClass::gmfRuntimeMetamodelType, GMFGEN::MetamodelType);
	if mmt.oclIsUndefined() then
	return self.map gmfRuntimeMetamodelType()
	endif;
	return object GMFGEN::SpecializationType { metamodelType := mmt }
	}

	-- XXX review - Specialization type is created again and again - why not reuse it?
	-- static, for some reasons, helpers couldn't specify 'inout' for context element
	-- XXX, actually, don't need GenNode here, GenClass should be sufficient
	helper setupElementType(inout genNode : GMFGEN::GenNode) {
	if genNode.modelFacet.oclIsUndefined() then genNode.elementType := object GMFGEN::NotationType {}
	else genNode.elementType := genNode.modelFacet.metaClass.getOrCreateRuntimeMetamodelType() endif;
	return;
	}

	helper setupElementType(inout genLink : GMFGEN::GenLink) {
	if genLink.modelFacet.oclIsUndefined() then
	genLink.elementType := object GMFGEN::NotationType {}
	else
	if genLink.modelFacet.oclIsKindOf(GMFGEN::TypeModelFacet) then
	genLink.elementType := genLink.modelFacet.oclAsType(GMFGEN::TypeModelFacet).metaClass.getOrCreateRuntimeMetamodelType()
	else { -- ref-based link; specialize null
	genLink.elementType := object GMFGEN::SpecializationType {};
	-- genLink.elementType.displayName := genLink.modelFacet.oclAsType(FeatureLinkModelFacet).metaFeature.ecoreFeature.name.firstToUpper();
	} endif
	endif;
	return;
	}

	helper GMFMAP::CanvasMapping::viewmap(): Viewmap =
	if useModeledViewmaps then
	object ModeledViewmap {
	figureModel := self.diagramCanvas.oclAsType(EObject);
	}
	else
	self.diagramCanvas.map Viewmaps::viewmap()
	endif;

	helper GMFMAP::TopNodeReference::viewmap(): Viewmap =
	if useModeledViewmaps then
	self.child.diagramNode.ModeledViewmaps::viewmap()
	else
	self.child.diagramNode.Viewmaps::viewmap()
	endif;

	helper GMFMAP::ChildReference::viewmap(_mapping: NodeMapping): Viewmap =
	if useModeledViewmaps then
	self.child.diagramNode.ModeledViewmaps::viewmap()
	else
	self.Viewmaps::viewmap(_mapping)
	endif;

	helper GMFMAP::LinkMapping::viewmap(): Viewmap =
	if useModeledViewmaps then
	self.diagramLink.ModeledViewmaps::viewmap()
	else
	self.diagramLink.Viewmaps::viewmap()
	endif;

	helper GMFMAP::LabelMapping::viewmap(): Viewmap =
	if useModeledViewmaps then
	self.diagramLabel.ModeledViewmaps::viewmap()
	else
	self.diagramLabel.Viewmaps::viewmap()
	endif;

	helper GMFMAP::CompartmentMapping::viewmap(): Viewmap =
	if useModeledViewmaps then
	self.compartment.ModeledViewmaps::viewmap()
	else
	self.compartment.Viewmaps::viewmap()
	endif;

	--
	-- Queries
	--

	query GMFMAP::Mapping::expressionsByLanguages(): Sequence(ValueExpression) =
	GMFMAP::ValueExpression.allInstances()->iterate(it; res: Sequence(ValueExpression) = Sequence{} \|
	if res->exists(e \| e.language = it.language) then res else res->including(it) endif
	);

	query GMFGRAPH::Node::getAffixedSideAsPositionConstantsName() : String =
	switch {
	case (self.affixedParentSide = GMFGRAPH::Direction::NONE) assert (false) with log('DiagramNode is not side-affixed', self);
	case (self.affixedParentSide = GMFGRAPH::Direction::EAST) return 'EAST';
	case (self.affixedParentSide = GMFGRAPH::Direction::WEST) return 'WEST';
	case (self.affixedParentSide = GMFGRAPH::Direction::NORTH) return 'NORTH';
	case (self.affixedParentSide = GMFGRAPH::Direction::SOUTH) return 'SOUTH';
	case (self.affixedParentSide = GMFGRAPH::Direction::NSEW) return 'NONE'; -- any side
	else return 'NONE'; -- any side
	};

	query DiagramElement::findAlignmentFacet(): AlignmentFacet =
	self.facets->selectOne(e \| e.oclIsKindOf(AlignmentFacet)).oclAsType(AlignmentFacet);