-- @atlcompiler emftvm
-- @path CFG=/uml2cs-instantmessenger-config/model/InstantMessenger.ecore
-- @path XML=/uml2cs-instantmessenger-config-editor/metamodels/XML.ecore
-- $Id: ConfigToBuildFile.atl 7633 2009-01-30 14:22:58Z dwagelaa $
-- Generates a build.xml file from a Transformations.ecore config file
module "InstantMessenger::ConfigToBuildFile";

create OUT : XML from IN : CFG;

uses "Transformations::ConfigToBuildFile";

-- ======================================================================
-- helper attributes begin
-- ======================================================================

helper def : ModelPath : String = 'platform:/resource/uml2cs-instantmessenger-model/models';

-- ======================================================================
-- helper attributes end
-- ======================================================================

-- ======================================================================
-- helper methods begin
-- ======================================================================

helper context CFG!"instantmessenger::InstantMessengerConfiguration"
def : localNetworkDepends() : Sequence(String) =
	if self.localNetwork.oclIsUndefined() then
		Sequence{}
	else
		Sequence{'LocalNetwork'}
	endif;
	
helper context CFG!"instantmessenger::InstantMessengerConfiguration"
def : jabberNetworkDepends() : Sequence(String) =
	if self.jabberNetwork.oclIsUndefined() then
		Sequence{}
	else
		if self.jabberNetwork.jabberTransport.oclIsKindOf(
			CFG!"instantmessenger::MEJabberTransport") then
			Sequence{'JabberNetwork', 'MEJabberTransport'}
		else
			Sequence{'JabberNetwork', 'DefaultJabberTransport'}
		endif
	endif;
	
helper context CFG!"instantmessenger::InstantMessengerConfiguration"
def : userInterfaceDepends() : Sequence(String) =
	if self.userInterface->select(u|u.oclIsKindOf(
		CFG!"instantmessenger::AWTUserInterface"))->notEmpty() then
		Sequence{'AWTUserInterface'}
	else
		Sequence{}
	endif
	->union(
	if self.userInterface->select(u|u.oclIsKindOf(
		CFG!"instantmessenger::SwingUserInterface"))->notEmpty() then
		Sequence{'SwingUserInterface'}
	else
		Sequence{}
	endif)
	->union(
	if self.userInterface->select(u|u.oclIsKindOf(
		CFG!"instantmessenger::LCDUIUserInterface"))->notEmpty() then
		Sequence{'LCDUIUserInterface'}
	else
		Sequence{}
	endif)
	->union(
	if self.userInterface->select(u|u.oclIsKindOf(
		CFG!"instantmessenger::SWTUserInterface"))->notEmpty() then
		Sequence{'SWTUserInterface'}
	else
		Sequence{}
	endif);

-- ======================================================================
-- helper methods end
-- ======================================================================

-- ======================================================================
-- transformation rules begin
-- ======================================================================

rule ConfigRoot {
	from s : CFG!"instantmessenger::InstantMessengerConfiguration"
	-- <project name="s.buildPath" default="all">
	to root : XML!"XML::Root" (
		name <- thisModule.ConfigHeader(s)),
	   default : XML!"XML::Attribute" (
	   	parent <- root,
	   	name <- 'default',
		value <- 'all'),
	-- <target name = 'all' depends = '...'>
	   allTarget : XML!"XML::Element" (
	   	name <- 'target',
		children <- thisModule.AllTarget(s),
		parent <- root),
	-- <target name = 'all-feedback' depends = '...'>
	   allFeedbackTarget : XML!"XML::Element" (
	   	name <- 'target',
		children <- thisModule.AllFeedbackTarget(s),
		parent <- root),
	-- <target name = 'InstantMessengerModel' depends = 'allBase'>
	   imTarget : XML!"XML::Element" (
	   	name <- 'target',
		children <- thisModule.ModelTarget(
			'InstantMessengerModel',
			'inModel',
			'im',
			thisModule.ModelPath + '/InstantMessengerModel.uml'),
		parent <- root),
	-- <target name = 'InstantMessengerModel-feedback' depends = 'allBase, loadJAVA'>
	   imTargetFeedback : XML!"XML::Element" (
	   	name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'InstantMessengerModel-feedback',
			'inModel',
			s.targetProject,
			thisModule.ModelPath + '/InstantMessengerModel.uml'),
		parent <- root)
}

rule LocalNetwork {
	from s : CFG!"instantmessenger::LocalNetwork"
	-- <target name = 'LocalNetwork' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'LocalNetwork',
			'Local',
			'local',
			thisModule.ModelPath + '/InstantMessengerLocal.uml'),
		parent <- s.config),
	-- <target name = 'LocalNetwork-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'LocalNetwork-feedback',
			'Local',
			s.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerLocal.uml'),
		parent <- s.config)
}

rule JabberNetwork {
	from s : CFG!"instantmessenger::JabberNetwork"
	-- <target name = 'JabberNetwork' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'JabberNetwork',
			'Jabber',
			'jabber',
			thisModule.ModelPath + '/InstantMessengerJabber.uml'),
		parent <- s.config),
	-- <target name = 'JabberNetwork-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'JabberNetwork-feedback',
			'Jabber',
			s.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerJabber.uml'),
		parent <- s.config)
}

rule DefaultJabberTransport {
	from s : CFG!"instantmessenger::DefaultJabberTransport"
	-- <target name = 'DefaultJabberTransport' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'DefaultJabberTransport',
			'DefaultJabber',
			'defaultjabber',
			thisModule.ModelPath + '/InstantMessengerDefaultJabber.uml'),
		parent <- s.jabberNetwork.config),
	-- <target name = 'DefaultJabberTransport-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'DefaultJabberTransport-feedback',
			'DefaultJabber',
			s.jabberNetwork.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerDefaultJabber.uml'),
		parent <- s.jabberNetwork.config)
}

rule MEJabberTransport {
	from s : CFG!"instantmessenger::MEJabberTransport"
	-- <target name = 'MEJabberTransport' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'MEJabberTransport',
			'MEJabber',
			'mejabber',
			thisModule.ModelPath + '/InstantMessengerMEJabber.uml'),
		parent <- s.jabberNetwork.config),
	-- <target name = 'MEJabberTransport-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'MEJabberTransport-feedback',
			'MEJabber',
			s.jabberNetwork.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerMEJabber.uml'),
		parent <- s.jabberNetwork.config)
}

rule AWTUserInterface {
	from s : CFG!"instantmessenger::AWTUserInterface"
	-- <target name = 'AWTUserInterface' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'AWTUserInterface',
			'AWT',
			'awt',
			thisModule.ModelPath + '/InstantMessengerAWT.uml'),
		parent <- s.config),
	-- <target name = 'AWTUserInterface-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'AWTUserInterface-feedback',
			'AWT',
			s.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerAWT.uml'),
		parent <- s.config)
}

rule SwingUserInterface {
	from s : CFG!"instantmessenger::SwingUserInterface"
	-- <target name = 'SwingUserInterface' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'SwingUserInterface',
			'Swing',
			'swing',
			thisModule.ModelPath + '/InstantMessengerSwing.uml'),
		parent <- s.config),
	-- <target name = 'SwingUserInterface-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'SwingUserInterface-feedback',
			'Swing',
			s.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerSwing.uml'),
		parent <- s.config)
}

rule LCDUIUserInterface {
	from s : CFG!"instantmessenger::LCDUIUserInterface"
	-- <target name = 'LCDUIUserInterface' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'LCDUIUserInterface',
			'LCDUI',
			'lcdui',
			thisModule.ModelPath + '/InstantMessengerLCDUI.uml'),
		parent <- s.config),
	-- <target name = 'LCDUIUserInterface-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'LCDUIUserInterface-feedback',
			'LCDUI',
			s.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerLCDUI.uml'),
		parent <- s.config)
}

rule SWTUserInterface {
	from s : CFG!"instantmessenger::SWTUserInterface"
	-- <target name = 'SWTUserInterface' depends = 'allBase'>
	to target : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelTarget(
			'SWTUserInterface',
			'SWT',
			'swt',
			thisModule.ModelPath + '/InstantMessengerSWT.uml'),
		parent <- s.config),
	-- <target name = 'SWTUserInterface-feedback' depends = 'allBase, loadJAVA'>
	   targetFeedback : XML!"XML::Element" (
		name <- 'target',
		children <- thisModule.ModelFeedbackTarget(
			'SWTUserInterface-feedback',
			'SWT',
			s.config.targetProject,
			thisModule.ModelPath + '/InstantMessengerSWT.uml'),
		parent <- s.config)
}

lazy rule AllTarget {
	from c : CFG!"instantmessenger::InstantMessengerConfiguration"
	-- Sequence{name="all" depends="..."}
	to targetName : XML!"XML::Attribute"(
	   	name <- 'name',
		value <- 'all'),
	   targetDepends : XML!"XML::Attribute"(
	   	name <- 'depends',
		value <- Sequence{'InstantMessengerModel'}
	   		->union(c.localNetworkDepends())
			->union(c.jabberNetworkDepends())
			->union(c.userInterfaceDepends())
			->append('prettyPrint')
			->iterate(e; acc : String = '' | acc +
				if acc = '' then e
				else ', ' + e endif).debug('All'))
	do {
		Sequence{targetName, targetDepends};
	}
}

lazy rule AllFeedbackTarget {
	from c : CFG!"instantmessenger::InstantMessengerConfiguration"
	-- Sequence{name="all-feedback" depends="..."}
	to targetName : XML!"XML::Attribute"(
	   	name <- 'name',
		value <- 'all-feedback'),
	   targetDepends : XML!"XML::Attribute"(
	   	name <- 'depends',
		value <- Sequence{'InstantMessengerModel-feedback'}
	   		->union(c.localNetworkDepends()->collect(d|d + '-feedback'))
			->union(c.jabberNetworkDepends()->collect(d|d + '-feedback'))
			->union(c.userInterfaceDepends()->collect(d|d + '-feedback'))
			->iterate(e; acc : String = '' | acc +
				if acc = '' then e
				else ', ' + e endif).debug('AllFeedback')),
	-- 	<eclipse.refreshLocal resource="thisModule.ModelPath"/>
	   refresh : XML!"XML::Element" (
	   	name <- 'eclipse.refreshLocal'),
	   refreshResource : XML!"XML::Attribute" (
	   	name <- 'resource',
		value <- thisModule.ModelPath,
		parent <- refresh)
	do {
		Sequence{targetName, targetDepends, refresh};
	}
}

rule ModelTarget(name : String, inModel : String, prefix : String, uri : String) {
	-- Sequence{name = 'name' depends = 'allBase'}
	to targetName : XML!"XML::Attribute"(
	   	name <- 'name',
		value <- name),
	   targetDepends : XML!"XML::Attribute"(
	   	name <- 'depends',
		value <- 'allBase'),
	-- <emftvm.loadModel name = 'inModel' uri = 'uri'/>
	   loadModel : XML!"XML::Element" (
	   	name <- 'emftvm.loadModel'),
	   modelName : XML!"XML::Attribute" (
	   	name <- 'name',
		value <- inModel,
		parent <- loadModel),
	   modelPath : XML!"XML::Attribute" (
	   	name <- 'uri',
		value <- uri,
		parent <- loadModel),
	-- <antcall target="generate" inheritRefs="true">
	   antcall : XML!"XML::Element" (
	   	name <- 'antcall'),
	   antcalltarget : XML!"XML::Attribute" (
	   	name <- 'target',
		value <- 'generate',
		parent <- antcall),
	   inheritRefs : XML!"XML::Attribute" (
	   	name <- 'inheritRefs',
		value <- 'true',
		parent <- antcall),
	-- <param name="in" value="inModel"/>
	   paramin : XML!"XML::Element" (
	   	name <- 'param',
		children <- thisModule.Property('in', inModel),
		parent <- antcall),
	-- <param name="prefix" value="prefix"/>
	   paramprefix : XML!"XML::Element" (
	   	name <- 'param',
		children <- thisModule.Property('prefix', prefix),
		parent <- antcall)
	do {
		Sequence{targetName, targetDepends, loadModel, antcall};
	}
}

rule ModelFeedbackTarget(name : String, inModel : String, targetProject : String, uri : String) {
	-- Sequence{name = 'name' depends = 'defineProperties, loadBaseModels, loadJAVA'}
	to targetName : XML!"XML::Attribute"(
	   	name <- 'name',
		value <- name),
	   targetDepends : XML!"XML::Attribute"(
	   	name <- 'depends',
		value <- 'defineProperties, loadBaseModels, loadJAVA'),
	-- <emftvm.loadModel name = 'inModel' uri = 'uri'/>
	   loadModel : XML!"XML::Element" (
	   	name <- 'emftvm.loadModel'),
	   modelName : XML!"XML::Attribute" (
	   	name <- 'name',
		value <- inModel,
		parent <- loadModel),
	   modelPath : XML!"XML::Attribute" (
	   	name <- 'uri',
		value <- uri,
		parent <- loadModel),
	-- <emftvm.loadModel name = 'inModelCode' wspath = '/targetProject/targetProject.javaast'/>
	   loadCode : XML!"XML::Element" (
	   	name <- 'emftvm.loadModel'),
	   cmodelName : XML!"XML::Attribute" (
	   	name <- 'name',
		value <- inModel + 'Code',
		parent <- loadCode),
	   cmodelPath : XML!"XML::Attribute" (
	   	name <- 'wspath',
		value <- '/' + targetProject + '/' + targetProject + '.javaast',
		parent <- loadCode),
	-- <antcall target="java2uml" inheritRefs="true">
	   antcall : XML!"XML::Element" (
	   	name <- 'antcall'),
	   antcalltarget : XML!"XML::Attribute" (
	   	name <- 'target',
		value <- 'java2uml',
		parent <- antcall),
	   inheritRefs : XML!"XML::Attribute" (
	   	name <- 'inheritRefs',
		value <- 'true',
		parent <- antcall),
	-- <param name="in" value="inModel"/>
	   paramin : XML!"XML::Element" (
	   	name <- 'param',
		children <- thisModule.Property('in', inModel),
		parent <- antcall),
	-- <param name="code" value="inModelCode"/>
	   paramcode : XML!"XML::Element" (
	   	name <- 'param',
		children <- thisModule.Property('code', inModel + 'Code'),
		parent <- antcall),
	-- <param name="uri" value="uri"/>
	   parampath : XML!"XML::Element" (
	   	name <- 'param',
		children <- thisModule.Property('uri', uri),
		parent <- antcall)
	do {
		Sequence{targetName, targetDepends, loadModel, loadCode, antcall};
	}
}

-- ======================================================================
-- transformation rules end
-- ======================================================================