cheddar2xml.atl

papyrus插件MARTE例子,uml建模

-- Thales MARTE to Cheddar (Copyright (c) THALES 2007 All rights reserved) is free software; you can redistribute itand/or modify
-- it under the terms of the Eclipse Public License as published in http://www.eclipse.org/legal/epl-v10.html
--
-- Thales MARTE to Cheddar is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
-- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Eclipse Public License for more details.

--------------------------------------------------
-- Eric MAES, Nicolas VIENNE
--------------------------------------------------
-- Transforms a Cheddar model to the XML metamodel
--------------------------------------------------
module cheddar2XML;
create OUT : XML from IN : CHEDDAR;

-- Toolkit functions
helper def: add (list:Sequence(XML!Element),element:XML!Element) : Sequence(XML!Element) =
	if (element.oclIsUndefined()) then
		list
	else
		list->append(element)
	endif;

-- Toolkit rules
rule Text (text:String,element:XML!Element) {
	to
		t : XML!Text (
			value <- text,
			parent <- element
		)
	do {
		element.children <- thisModule.add(element.children,t);
	}
}

rule Attribute(attributeName:String,attributeValue:String,element:XML!Element) {
	to
		a : XML!Attribute (
			name <- attributeName,
			value <- attributeValue,
			parent <- element
		)
	do {
		element.children <- thisModule.add(element.children,a);
	}
}

rule ElementText (elementName:String,elementValue:String,element:XML!Element) {
	to
		e : XML!Element (
			name <- elementName,
			parent <- element
		)
	do {
		thisModule.Text(elementValue,e);
		element.children <- thisModule.add(element.children,e);
	}
}



rule Scheduler(scheduler:CHEDDAR!scheduler,host:CHEDDAR!Element) {
	to
		element : XML!Element (
			name <- 'scheduler',
			parent <- host,
			children <- Sequence {}
		)
	do {
		if (not scheduler.parametric_filename.oclIsUndefined()) {
			thisModule.Attribute('parametric_filename',scheduler.parametric_filename,element);
		}
		if (not scheduler.is_preemptive.oclIsUndefined()) {
			thisModule.Attribute('is_preemptive',scheduler.is_preemptive.toString(),element);
		}
		if (not scheduler.quantum.oclIsUndefined()) {
			thisModule.Attribute('quantum',scheduler.quantum.toString(),element);
		}
		
		if (not scheduler.policy.oclIsUndefined()) {
			thisModule.Text(scheduler.policy.toString(),element);
		}
		thisModule.add(host.children,element);
	}
}

rule Network (network:CHEDDAR!network,host:CHEDDAR!Element) {
	to
		element : XML!Element (
			name <- 'network_link',
			parent <- host,
			children <- Sequence {}
		)
	do {
		if (not network.value.oclIsUndefined()) {
			thisModule.Text(network.value,element);
		}
		thisModule.add(host.children,element);
	}
}

rule Parameter (parameter:CHEDDAR!parameter,host:CHEDDAR!Element) {
	to
		element : XML!Element (
			name <- 'parameter',
			parent <- host,
			children <- Sequence {}
		)
	do {
		if (not parameter.parameter_type.oclIsUndefined()) {
			thisModule.Attribute('parameter_type',parameter.parameter_type.toString(),element);
		}
		if (not parameter.name.oclIsUndefined() and not parameter.value.oclIsUndefined()) {
			thisModule.Text(parameter.name+' '+parameter.value.toString(),element);
		}
		thisModule.add(host.children,element);
	}
}

rule Offset (offset:CHEDDAR!offset,host:CHEDDAR!Element) {
	to
		element : XML!Element (
			name <- 'offset',
			parent <- host,
			children <- Sequence {}
		)
	do {
		if (not offset.activation.oclIsUndefined() and not offset.value.oclIsUndefined()) {
			thisModule.Text(offset.activation.toString()+' '+offset.value.toString().toString(),element);
		}
		thisModule.add(host.children,element);
	}
}

rule ResourceUser (resource_user:CHEDDAR!resource_user,host:CHEDDAR!Element) {
	to
		element : XML!Element (
			name <- 'resource_user',
			parent <- host,
			children <- Sequence {}
		)
	do {
		if (not resource_user.task_name.oclIsUndefined() and not resource_user.start_time.oclIsUndefined() and not resource_user.end_time.oclIsUndefined()) {
			thisModule.Text(resource_user.task_name.name+' '+resource_user.start_time.toString()+' '+resource_user.end_time.toString(),element);
		}
		thisModule.add(host.children,element);
	}
}

rule BufferUser (buffer_user:CHEDDAR!buffer_user,host:CHEDDAR!Element) {
	to
		element : XML!Element (
			name <- 'buffer_user',
			parent <- host,
			children <- Sequence {}
		)
	do {
		
		if (not buffer_user.buffer_role.oclIsUndefined()) {
			thisModule.Attribute('buffer_role',buffer_user.buffer_role.toString(),element);
		}
		if (not buffer_user.task_name.oclIsUndefined() and not buffer_user.time.oclIsUndefined() and not buffer_user.size.oclIsUndefined()) {
			thisModule.Text(buffer_user.task_name.name+'  '+buffer_user.size.toString()+'  '+buffer_user.time.toString()+' ',element);
		}
		thisModule.add(host.children,element);
	}
}

rule Processors(root:XML!Root) {
	to
		processors : XML!Element (
			name <- 'processors',
			children <- CHEDDAR!processor.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,processors);
	}
}

rule AddressSpaces(root:XML!Root) {
	to
		address_spaces : XML!Element (
			name <- 'address_spaces',
			children <- CHEDDAR!address_space.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,address_spaces);
	}
}

rule Tasks(root:XML!Root) {
	to
		tasks : XML!Element (
			name <- 'tasks',
			children <- CHEDDAR!task.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,tasks);
	}
}

rule Resources(root:XML!Root) {
	to
		resources : XML!Element (
			name <- 'resources',
			children <- CHEDDAR!resource.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,resources);
	}
}

rule Buffers(root:XML!Root) {
	to
		buffers : XML!Element (
			name <- 'buffers',
			children <- CHEDDAR!buffer.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,buffers);
	}
}

rule Dependencies(root:XML!Root) {
	to
		dependencies : XML!Element (
			name <- 'dependencies',
			children <- CHEDDAR!dependency.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,dependencies);
	}
}

rule Messages(root:XML!Root) {
	to
		messages : XML!Element (
			name <- 'messages',
			children <- CHEDDAR!message.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,messages);
	}
}

rule EventAnalyzers(root:XML!Root) {
	to
		event_analyzers : XML!Element (
			name <- 'event_analyzers',
			children <- CHEDDAR!event_analyzer.allInstances()
		)
	do {
		root.children <- thisModule.add(root.children,event_analyzers);
	}
}

rule Parameters(task:CHEDDAR!task,host:XML!Element) {
	to
		parameters : XML!Element (
			name <- 'parameters',
			children <- Sequence{}
		)
	do {
		for (ts in task.parameters)  {
			thisModule.Parameter(ts,parameters);
		}
		host.children <- thisModule.add(host.children,parameters);
	}
}

rule Offsets(task:CHEDDAR!task,host:XML!Element) {
	to
		offsets : XML!Element (
			name <- 'offsets',
			children <- Sequence{}
		)
	do {
		for (ts in task.offsets)  {
			thisModule.Offset(ts,offsets);
		}
		host.children <- thisModule.add(host.children,offsets);
	}
}

rule ResourceUsedBy(resource:CHEDDAR!resource,host:XML!Element) {
	to
		resource_used_by : XML!Element (
			name <- 'resource_used_by',
			children <- Sequence{}
		)
	do {
		for (rs in resource.resource_used_by)  {
			thisModule.ResourceUser(rs,resource_used_by);
		}
		host.children <- thisModule.add(host.children,resource_used_by);
	}
}

rule BufferUsedBy(buffer:CHEDDAR!buffer,host:XML!Element) {
	to
		buffer_used_by : XML!Element (
			name <- 'buffer_used_by',
			children <- Sequence{}
		)
	do {
		for (bs in buffer.buffer_used_by)  {
			thisModule.BufferUser(bs,buffer_used_by);
		}
		host.children <- thisModule.add(host.children,buffer_used_by);
	}
}