Wiki source code of SCCharts Development

Version 72.1 by Niklas Rentz on 2023/09/12 12:30

version	line-number	content
49.1	1	This is a light-weight tutorial for developing transformations/additions for SCCharts in KIELER. It will use Eclipse, EMF, and Xtend and therefore, finishing the corresponding tutorials could prove useful. However, they are not a strict requirement for this tutorial.
1.1	2
51.1	3	{{warning title="Outdated!"}}
	4	The KiCo part "Model-to-Model Transformations with KiCo" is outdated. We will update this tutorials in the near future.
	5	{{/warning}}
12.1	6
51.1	7	\\
12.1	8
51.1	9
	10
12.1	11	{{toc/}}
	12
1.1	13	= Preliminaries =
	14
	15	There's a few things to do before we dive into the tutorial itself. For example, to do Eclipse programming, you will have to get your hands on an Eclipse installation first. Read through the following sections to get ready for the tutorial tasks.
	16
	17	== Required Software ==
	18
25.1	19	As you're going to develop for KIELER SCCharts, we recommend to use the Oomph setup as described in [[doc:KIELER.Getting Eclipse]] (Oomph Setup). However, you could also install all componentes by yourself. Please consult the other tutorials if you want to do that. You would need to install the Modeling Tools and the Xtext SDK.
1.1	20
71.1	21
51.1	22	\\
11.1	23
7.1	24	Additionally, install the EcoreViz from the Ecore Model Visualization category from the OpenKieler update site: [[http:~~/~~/rtsys.informatik.uni-kiel.de/~~~~kieler/updatesite/nightly-openkieler/>>url:http://rtsys.informatik.uni-kiel.de/~~kieler/updatesite/nightly-openkieler/\|\|rel="nofollow" shape="rect"]]. For this, choose //Install New Software...// in the //Help// tab.
8.1	25
	26	Due to the ongoing migration you have to install a workaround for EcoreViz to function. You have to install the KLighD diagram view directly from [[http:~~/~~/rtsys.informatik.uni-kiel.de/~~~~kieler/updatesite/release_pragmatics_2016-02/>>url:http://rtsys.informatik.uni-kiel.de/~~kieler/updatesite/release_pragmatics_2016-02/\|\|shape="rect"]]. Select the features
	27
	28	* KIELER Lightweight Diagrams - Developer Resources and
	29	* KIELER Lightweight Diagrams Generic Diagram View.
	30
	31	(This step should be obsolete in the near future.)
1.1	32
51.1	33	\\
11.1	34
7.1	35	[[image:attach:InstallEcoreViz.png]]
12.1	36
11.1	37
72.1	38	\\\\
	39
8.1	40	[[image:attach:InstallKLighDFeatures.png]]
7.1	41
1.1	42	== Recommended Tutorials ==
	43
	44	We recommend that you have completed the following tutorials before diving into this one (or at least sweep over them). However, this is not a strict requirement.
	45
68.1	46	1. [[doc:KIELER.Development.Tutorials.Eclipse.Eclipse Plug-ins and Extension Points.WebHome]]
67.1	47	1. [[doc:KIELER.Development.Tutorials.Eclipse.Eclipse Modeling Framework (EMF).WebHome]]
1.1	48	11. This tutorial needs the turingmachine.ecore and the controller you've implemented in the EMF tutorial. If you did not complete the EMF tutorial, you may download a working turing machine here... (in the future).
	49	1. (((
	50	(% class="with-breadcrumbs" %)
	51	[[Xtend 2 - Model Transformations>>url:http://rtsys.informatik.uni-kiel.de/confluence/display/TUT/Xtend+2+-+Model+Transformations\|\|shape="rect"]]
	52	)))
	53
	54	== Helpful Tutorials ==
	55
	56	When developing within the KIELER semantics team, you will most likely be confronted with Xtext and [[doc:KIELER.Lightweight Diagrams (KLighD)]]. The following tutorials may be helpful but not required for this tutorial.
	57
70.1	58	1. [[doc:KIELER.Development.Tutorials.Xtext and Xtend.Xtext 2 - Creating a Grammar from Scratch.WebHome]]
66.1	59	1. [[doc:KIELER.Development.Tutorials.Diagrams and Layout.Lightweight Diagrams (KLighD).WebHome]]
1.1	60
	61	== Finding Documentation ==
	62
50.1	63	You can find additional documentation to the aforementioned topics in the corresponding tutorials. If you get stuck with a particular topic, please consult that tutorial. For SCCharts, you should read the SCCharts confluence page in our wiki: [[doc:KIELER.SCCharts (pre 1\.0)]]
1.1	64
	65	As usual, documentation often gets obsolete or wrong if not maintained regularly, so please, if you find missing, misleading, or outdated information, please let us know.
	66
	67	Additionally, the following list will give a short overview over the most important publications:
	68
	69	* (% style="color: rgb(0,0,0);" %)Main paper:
51.1	70	Reinhard von Hanxleden and Björn Duderstadt and Christian Motika and Steven Smyth and Michael Mendler and Joaquín Aguado and Stephen Mercer and Owen O’Brien. SCCharts: Sequentially Constructive Statecharts for Safety-Critical Applications. In (% class="cmti-10" %)Proc. ACM SIGPLAN Conference on Programming Language Design(%%) (% class="cmti-10" %)and Implementation (PLDI’14)(%%), Edinburgh, UK, June 2014. ACM. [[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/pldi14.pdf\|\|shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[talk>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/talks/pldi14-talk.pdf\|\|shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=vonHanxledenDM+14\|\|shape="rect"]]
1.1	71	* SLIC Compilation:
51.1	72	(% style="color: rgb(0,0,0);" %)Christian Motika and Steven Smyth and Reinhard von Hanxleden. Compiling SCCharts—A Case-Study on Interactive Model-Based Compilation. In (% class="cmti-10" %)Proceedings of(%%) (% class="cmti-10" %)the 6th International Symposium on Leveraging Applications of Formal(%%) (% class="cmti-10" %)Methods, Verification and Validation (ISoLA 2014)(%%), volume 8802 of (% class="cmti-10" %)LNCS(%%), page 443–462, Corfu, Greece, October 2014. The [[original publication>>url:http://dx.doi.org/10.1007/978-3-662-45234-9\|\|shape="rect"]](% style="color: rgb(0,0,0);" %) is available at (%%)[[http:~~/~~/link.springer.com>>url:http://link.springer.com/\|\|shape="rect"]](% style="color: rgb(0,0,0);" %). (%%)[[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/isola14.pdf\|\|shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=MotikaSvH14\|\|shape="rect"]]
1.1	73	* Theoretical Foundations:
51.1	74	(% style="color: rgb(0,0,0);" %)Reinhard von Hanxleden and Michael Mendler and Joaquín Aguado and Björn Duderstadt and Insa Fuhrmann and Christian Motika and Stephen Mercer and Owen O’Brien and Partha Roop. Sequentially Constructive Concurrency—A Conservative Extension of the Synchronous Model of Computation. (% class="cmti-10" %)ACM Transactions on Embedded Computing(%%) (% class="cmti-10" %)Systems, Special Issue on Applications of Concurrency to System Design(%%), 13(4s):144:1–144:26, July 2014. [[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/tecs14.pdf\|\|shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=vonHanxledenMA+14\|\|shape="rect"]]
1.1	75	* Overview and High-Level Transformations in Detail:
	76	(% style="color: rgb(0,0,0);" %)Reinhard von Hanxleden and Björn Duderstadt and Christian Motika and Steven Smyth and Michael Mendler and Joaquín Aguado and Stephen Mercer and Owen O’Brien. SCCharts: Sequentially Constructive Statecharts for Safety-Critical Applications. Technical Report 1311, Christian-Albrechts-Universität zu Kiel, Department of Computer Science, December 2013. ISSN 2192-6247. (%%)[[pdf>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/downloads/papers/report-1311.pdf\|\|shape="rect"]](% style="color: rgb(0,0,0);" %), (%%)[[bib>>url:http://rtsys.informatik.uni-kiel.de/~~biblio/cgi-bin/bibcgi.cgi?key=vonHanxledenDM+13b\|\|shape="rect"]]
13.1	77
51.1	78	\\
1.1	79
	80	= The SCCharts Metamodel =
	81
9.1	82	Navigate to the {{code language="none"}}models{{/code}} folder of the plugin {{code language="none"}}de.cau.cs.kieler.sccharts{{/code}}. Here, open the {{code language="none"}}sccharts.ecore{{/code}} and right-click on the {{code language="none"}}sccharts.ecore{{/code}} file and select //Visualize Ecore Model//. Since you also installed EcoreViz from the OpenKieler Suite, you should now see a graphical representation of the SCCharts metamodel. Every SCChart will be a model of this metamodel.
1.1	83
14.1	84	To see all class information check //Attributes/Literals// in the Diagram Options on the right.
	85
15.1	86	EcoreViz gives you an overview over the selected Ecore diagram. However, Ecore model definitions may depend on other Ecore definitions that are not displayed in the diagram. You can open new diagrams for these Ecore files as described before or use the Ecore tree editor to inspect all classes.
	87
1.1	88	Try to understand most parts of the metamodel. You don't have to understand every detail but you should get the idea.
	89
	90	==== Model Task ====
	91
48.1	92	* (((
25.1	93	(% style="line-height: 1.42857;" %)Answer the following questions
4.1	94
25.1	95	1. How do you describe a superstate in the model?
	96	1. Outline the relationship between states, regions, transitions, and valued objects.\\
	97	1. Name the class of the root element of an SCChart.
	98	1. What is a valued object?
	99	1. How do you get the type of an interface variable?
	100	1. What other metamodels are needed for the SCCharts metamodel and write down which one is needed for what?
48.1	101	)))
	102	* Write down (on paper, text editor, etc) how the following SCChart models look like
	103	*1. Open the wiki page that explains the [[doc:KIELER.Textual SCCharts Language SCT]].
	104	*1. Search the //SCChart, Initial State, State, Transition and Immediate Transition //example and ...
	105	*11. write down (on paper or text editor, etc) how the model of that SCChart looks like.
	106	*11. The user now marks C as final. What has to be changed in the model? What semantic problem do you see?
	107	*1. Now, navigate to the //Super State: Strong Abort Transition //example. Write down (on paper) how the model of that SCCharts looks like.
	108	*1. And finally a more sophisticated model: Write down the model of ABO (from [[doc:KIELER.Examples]]).
25.1	109
51.1	110	\\
9.1	111
	112	{{info title="KLighD Screenshots"}}
17.1	113	By the way: You can //right-click// on the Diagram View surface and select //Save as image...// to create a screenshot!
9.1	114	{{/info}}
	115
	116	[[image:attach:sccharts_metamodel.png]]
	117
15.1	118	[[image:attach:sccharts_metamodel_treeEditor.png]]
9.1	119
	120	[[image:attach:KLighDSaveAsImage.png]]
	121
72.1	122	= Creating SCCharts Models Programmatically =
4.1	123
	124	== Creating a Test Project ==
	125
	126	We need a project for testing. Do the following:
	127
48.1	128	* If you used the standard KIELER Oomph installation setup, create a new Working Set named Tutorial in the Package Explorer. Then...
	129	* Create a new empty //Plug-In Project//.
	130	* Add the project that contains the sccharts metamodel as a dependency of your new project through the //Plugin Manifest Editor//.
	131	* Create a simple Java class that implements a main method. Hint: In a new Java class, simply type main and hit Ctrl+Space. Eclipse content assist will create the method for you.
4.1	132
	133	== Creating a Model ==
	134
18.1	135	To create a model programmatically you cannot directly use the Java classes generated for the model. Instead, the main package contains interfaces for all of your model object classes. The {{code language="none"}}impl{{/code}} package contains the actual implementation and the {{code language="none"}}util{{/code}} package contains some helper classes. Do not instantiate objects directly by manually calling {{code language="none"}}new{{/code}}. EMF generates a Factory to create new objects. The factory itself uses the singleton pattern to get access to it:
4.1	136
	137	{{code language="java"}}
	138	SCChartsFactory sccFactory = SCChartsFactory.eINSTANCE;
19.1	139	State state = sccFactory.createState();
	140	Transition transition = sccFactory.createTransition();
4.1	141	{{/code}}
	142
	143	Important: The SCCharts grammar is build on top of several other grammars. Therefore, not all language objects can be found in the SCCharts factory. For example, all expression elements are part of the KExpressions grammar and hence, have their own factory. If you need other factories, don't forget to add the corresponding plugin to your plugin dependency list.
	144
	145	{{code language="java"}}
	146	KExpressionsFactory kFactory = KExpressionsFactory.eINSTANCE;
18.1	147	BoolValue boolValue = kFactory.createBoolValue();
4.1	148	{{/code}}
	149
	150	For all simple attributes, there are getter and setter methods:
	151
	152	{{code language="java"}}
19.1	153	state.setId("Init");
4.1	154	boolValue.setValue(true);
	155	{{/code}}
	156
	157	Simple references (multiplicity of 1) also have getters and setters:
	158
	159	{{code language="java"}}
	160	transition.setTrigger(boolValue);
	161	{{/code}}
	162
	163	List references (multiplicity of > 1) have only a list getter, which is used to manipulate the list:
	164
	165	{{code language="java"}}
18.1	166	state.getOutgoingTransitions().add(transition);
4.1	167	{{/code}}
	168
18.1	169	{{info title="Plugin Dependencies"}}
	170	You may have noticed that is was not necessary to add a dependency for the kexpressions classes. The SCCharts plugin reexports the dependencies of the other EMF metamodels. Look at the plugin.xml in the SCCharts plugin in the dependency tab for more information.
	171	{{/info}}
	172
4.1	173	== Saving a Model ==
	174
	175	EMF uses the [[Eclipse Resource concept>>url:http://help.eclipse.org/juno/topic/org.eclipse.platform.doc.isv/guide/resInt.htm?cp=2_0_10\|\|rel="nofollow" shape="rect" class="external-link"]] to save models to files and load models from files. It can use different //Resource Factories// that determine how exactly models are serialized. We will use the [[XMIResourceFactoryImpl>>url:http://download.eclipse.org/modeling/emf/emf/javadoc/2.8.0/org/eclipse/emf/ecore/xmi/impl/XMIResourceFactoryImpl.html\|\|rel="nofollow" shape="rect" class="external-link"]] to save our models to XML files:
	176
48.1	177	* (((
19.1	178	Add a dependency to the {{code language="none"}}com.google.inject, org.eclipse.core.resources, {{/code}}and{{code language="none"}} de.cau.cs.kieler.sccharts.text{{/code}} plug-ins.
	179
	180	{{info title="Additional Dependencies"}}
	181	Don't worry. You will be experienced enough to add mandatory dependencies quickly in the future. However, for now just add the dependencies to proceed with the tutorial.
	182	{{/info}}
	183	)))
48.1	184	* (((
4.1	185	Use something like the following code to save the model from above:
	186
	187	{{code language="java"}}
	188	// Create a resource set.
	189	ResourceSet resourceSet = new ResourceSetImpl();
	190
19.1	191	// Register the resource factory -- only needed for stand-alone!
	192	SctStandaloneSetup.doSetup();
	193
	194
4.1	195	// Get the URI of the model file.
	196	URI fileURI = URI.createFileURI(new File("myABO.sct").getAbsolutePath());
	197
	198	// Create a resource for this file.
	199	Resource resource = resourceSet.createResource(fileURI);
	200
50.1	201	// Add the model objects to the contents. Usually, this is the root node of the model.
4.1	202	resource.getContents().add(myModel);
	203
	204	// Save the contents of the resource to the file system.
	205	try
	206	{
	207	resource.save(Collections.EMPTY_MAP); // the map can pass special saving options to the operation
	208	} catch (IOException e) {
	209	/* error handling */
	210	}
	211	{{/code}}
20.1	212
	213	{{info title="File Extensions"}}
	214	File extensions are important! They define the parser/serializer that EMF uses. Always use the file extension that is defined for a particular model.
	215	{{/info}}
4.1	216	)))
	217
	218	==== Model Creation Task ====
	219
19.1	220	You are now equipped with the fundamentals you need to create models programmatically. Let's try it:
4.1	221
48.1	222	* (% style="line-height: 1.42857;" %)The code fragments listed above do not suffice to create a grammatically correct model. Try to generate a model that corresponds with the serialized model listed on the right side.
	223	*1. (% style="line-height: 1.42857;" %)Run the {{code language="none"}}main(){{/code}} method by right-clicking its class and selecting //Run as// -> //Java Application//. Note that this runs your {{code language="none"}}main(){{/code}} method as a simple Java program, not a complete Eclipse application. EMF models can be used in any simple Java context, not just in Eclipse applications.
	224	*1. Execute the main method.
	225	*1. (((
25.1	226	(% style="line-height: 1.42857;" %)Inspect your SCT file. (Press F5 to refresh your file view.)
	227
20.1	228	{{note title="Kext Warning"}}
	229	It is possible that kext generates a Null Pointer Exception when you save your model this way. This is a known issue. We're working on it. Just ignore it for now.
	230	{{/note}}
	231	)))
48.1	232	* Now, create a new Java class and proceed as before to generate a model of ABO in the {{code language="none"}}main(){{/code}} method.
	233	* (% style="line-height: 1.42857;" %)Start your SCChart Editor Eclipse instance and load your SCT file. KLighD should now be able to visualize your ABO correctly.(%%)\\
	234	*1. For this, open tab //Run// and select// Run Configurations...//
	235	*1. Create a new //Eclipse Application// and name it appropriately.
	236	*1. As product select {{code language="none"}}de.cau.cs.kieler.core.product.product{{/code}}.
	237	*1. Click //Run// (or //Debug// if you opened// Debug Configuration...//)
	238	*1. Create a new project and add you generated model.
19.1	239
51.1	240	\\
19.1	241
	242	{{code language="java" title="Root.sct"}}
	243	scchart Root {
	244	initial state Init
	245	--> Init with true;
	246	}
	247	{{/code}}
20.1	248
	249	[[image:attach:RunConfiguration.png]]
4.1	250
22.1	251	= Model-to-Model Transformations with KiCo =
20.1	252
24.1	253	You can use the [[Kieler Compiler>>url:http://rtsys.informatik.uni-kiel.de/confluence/display/KIELER/Kieler+Compiler\|\|shape="rect"]] (KiCo) to handle all the model input/output tasks and concentrate on the actual transformation. If you executed the Model Creation Task correctly, you should now have a complete running SCT Editor instance that looks like the one on the right. You should see the //KIELER Compiler Selection// n the lower right part of the working space. Here you can select specific transformations that will be applied to the actual model. Simply select a transformation to test it.
20.1	254
	255	== Creating a new Transformation ==
	256
24.1	257	Now, you're going to write your own transformation with Xtend drumroll, a programming language that looks very similar to Java, but which adds some very convenient features. Xtend code compiles to Java and and was developed using Xtext. In fact, once you gain experience working with Xtend you will probably appreciate the power of Xtext even more. Xtend is particularly useful to browse & modify EMF models. You get the point... we like it. :)
20.1	258
25.1	259	[[image:attach:KielerSCTEditor.png]]
20.1	260
22.1	261	==== Transformation Creation Task ====
20.1	262
48.1	263	* Create your first transformation...
	264	*1. Create a new project within your tutorial working set as before.
	265	*1. Add plugin dependencies to {{code language="none"}}de.cau.cs.kieler.kico{{/code}} and {{code language="none"}}de.cau.cs.kieler.sccharts{{/code}}.
	266	*1. Create a new //Xtend class// in you package and name it "DoubleStates" and use {{code language="none"}}AbstractProductionTransformation{{/code}} as superclass.
	267	*1. Here, you can automatically add the missing Xtend files by using the quickfix //Add Xtend lib to class path. //Alternatively you can simply add {{code language="none"}}com.google.guava{{/code}}, {{code language="none"}}org.eclipse.xtext.xbase.lib{{/code}}, {{code language="none"}}org.eclipse.xtend.lib{{/code}}, and {{code language="none"}}org.eclipse.xtend.lib.macro{{/code}} to you plugin dependencies.
	268	*1. Click on //Add unimplemented methods//.
	269	*1. (((
20.1	270	Now, you should have a class similar to the following one.
	271
	272	{{code language="java"}}
	273	package tutorial.transformation
	274
	275	import de.cau.cs.kieler.kico.transformation.AbstractProductionTransformation
	276
	277	class DoubleStates extends AbstractProductionTransformation {
	278
	279	override getProducedFeatureId() {
	280	throw new UnsupportedOperationException("TODO: auto-generated method stub")
	281	}
	282
	283	override getId() {
	284	throw new UnsupportedOperationException("TODO: auto-generated method stub")
	285	}
	286
	287	}
	288	{{/code}}
22.1	289
	290	{{info title="Xtend Infos"}}
	291	* Lines in Xtend code don't have to and with a semicolon.
	292	* We have been explicit about the method's return type, but we could have easily omitted it, letting Xtend infer the return type.
	293	* The keyword {{code language="none"}}val{{/code}} declares a constant, while {{code language="none"}}var{{/code}} declares a variable. Try to make do with constants where possible.
	294	* The methods you call should be declared as {{code language="none"}}def private{{/code}} since they are implementation details and shouldn't be called by other classes.
	295	* You may be tempted to add a few global variables that hold things like a global input variable or a pointer to the current state. While you could to that, {{code language="none"}}def create {{/code}}methods might offer a better alternative...
	296	{{/info}}
20.1	297	)))
48.1	298	* (((
25.1	299	As you can see, it is mandatory to add an id for the transformation and another id of the feature that this transformation produces. Name your transformation tutorial.doubleStates and the id of feature you want to produce is sccharts.doubleStates.
	300
20.1	301	{{info title="Programming Guidelines"}}
	302	You should really think about some constants here. You can also look at the sccharts transformation and features constants in the sccharts plugin.
	303	{{/info}}
48.1	304	)))
25.1	305
48.1	306	* KiCo must know about the new feature and also about your new transformation.
	307	1. Add a new Xtend class with Feature as superclass. Add all unimplemented methods. Also set* sccharts.doubleStates** as Id.
	308	*1. Go to the Extension tab inside your plugin configuration.
	309	*11. Add a new Extension Point de.cau.cs.kieler.kico.feature. Create a new featureClass and point it to your new feature class.
	310	*11. Also add a new Extension Point de.cau.cs.kieler.kico.transformation. Create a new productionTransformationClass and point it to your transformation class.
	311	*11. Finally, you have to link your transformation to the SCT Editor. Add the Extension point de.cau.cs.kieler.kico.ui.transformation. Create an editor link and fill in the following values:
	312	*111. editor: {{code language="none"}}de.cau.cs.kieler.sccharts.text.sct.Sct{{/code}}
	313	*111. features: sccharts.doubleStates
	314	*111. label: Tutorial Compilation
	315	*111. priority: 101
	316	*111. preferred: (leave it blank)
	317	*1. {{note title="Plugin Tasks"}}In general it is bad to mix non-ui plugins/tasks with ui plugin/tasks because (in the context of KiCo) even if you're not working with an active UI your transformations should work (e.g. a command line compiler). To keep this tutorial simple, you can add this dependency to your plugin nevertheless. However, you shouldn't do this in real products. Always keep the UI separated.{{/note}}If you start your KIELER instance now, you should get a new compilation chain which has only one transformation: yours, which doesn't do anything.
	318	* If you want to rename your feature in the Compiler Selection (without changing its Id), override the {{code language="none"}}getName{{/code}} method and return a new name. Rename your feature appropriately.
25.1	319
	320	[[image:attach:KielerSCTEditorOwnTransformation.png]]
	321
48.1	322	* Now, fill your transformation with life:
	323	*1. Inside your transformation class, add a new method with the following signature: {{code language="none"}}def State transform(State rootState, KielerCompilerContext context){{/code}}. This transformation will be executed if the feature is selected in the Compiler Selection.
	324	*1. (((
22.1	325	Add thew following body to the function and try to understand the Xtend code. Import unknown class via code assist.
20.1	326
21.1	327	{{code language="java" title="transform"}}
	328	def State transform(State rootState, KielerCompilerContext context) {
	329	val newState = SCChartsFactory.eINSTANCE.createState => [
	330	id = "ololo"
	331	label = "ololo"
	332	]
	333
	334	rootState.regions.filter(ControlflowRegion).head.states += newState
	335
	336	rootState
	337	}
	338	{{/code}}
	339	)))
48.1	340	*1. When selecting your transformation, the SCChart gets transformed and looks like the version on the right.
	341	* Extend the transformation so that the transition is split up in two and connected via a transient state meaning that the original transformation should point to the new state and a new immediate transformation then points to the original target state. Try it out.
	342	* (((
25.1	343	Xtend supports extensions that can be used to extend the function set of you classes (i.e. models). Add {{code language="none"}}com.google.inject{{/code}} to the dependencies of your plugin. Now, add the following code fragment to the beginning of your class.
	344
22.1	345	{{code language="java" title="Code injection"}}
	346	@Inject
	347	extension SCChartsExtension
	348	{{/code}}
	349
25.1	350	There are several Extensions classes within the KIELER project that extend the functionality of various classes. Basically, there are one or more for each metamodel (e.g. SCCharts, SCG, KExpressions, etc). You don't want to invent the wheel again. Use these methods. For example: there is a method that gives you all contained states of a state in a list: {{code language="none"}}getAllContainedStatesList{{/code}}. You can use it on your {{code language="none"}}rootState{{/code}}: {{code language="none"}}rootState.allContainedStatesList{{/code}}. There are also several convenient methods for creating model elements so that you don't have to use the factories directly.
22.1	351
	352	{{note title="Extensions Naming Scheme"}}
	353	Extensions are also just classes. You can add your own to improve the structure of your own projects. In KIELER all extensions end with "Extensions"; except SCChartsExtension for legacy reasons. This will be renamed in after the next snapshot to SCChartsExtensions. So, if you're going to add new extensions to the project, please name them accordingly.
	354	{{/note}}
48.1	355	)))
22.1	356
25.1	357	[[image:attach:KielerSCTEditorOwnTransformationOlolo.png]]
	358
71.1	359
	360
48.1	361	* Extend your transformation so that it is applied on all states (except the root state). Try your new transformation with ABO. The result should look like the example on the right.
25.1	362
22.1	363	== The existing Compilation Chain ==
	364
	365	Congratulations. You added and executed your own KiCo transformation. Nevertheless, often you want to extend the existing compilation chain. To do this, you proceed as before but instead of creating your own compilation chain, you must modify the existing chains (e.g. the netlist compilation in de.cau.cs.kieler.sccharts.ui). To add a specific transformation at a specific point in the chain, you must tell KiCo what features are required for the transformation. For that you must override the method getRequiredFeatureIds and return a set with all required features.
	366
	367	Also, if you're developing for the master chain, you should obey the package structure. Look at the sccharts plugins. All features, transformation, extensions, the metamodel, ui elements, etc are separated from each other. You should always do the same!
	368
	369	//We will add more content to this subsection in the future...//
	370
51.1	371	\\
19.1	372
25.1	373	[[image:attach:ABODoubleStates.png]]
20.1	374
51.1	375	\\
22.1	376
51.1	377	\\
22.1	378
	379	= Model-to-Model Transformations between Metamodels =
4.1	380
22.1	381	Transformations from one model to another may be performed within the same metamodel or from metamodel to a different metamodel. Both methods are used in KIELER and in principle they do not really differ in implementation. Nevertheless, if working within the same metamodel you should keep in mind that you're potentially changing the actual model instead of changing another instance (after copying). When transforming to another metamodel, you're always generating a new model. So there is no in-place transformation. Both is possible. Just make sure that you know what you're doing.
4.1	382
	383	Now, you're going to transform the normalized form of HandleA from ABO to an SCG. The Sequentially Constructive Graph is a control-flow graph which can be seen as another representation of the same program. The SCG of the normalized version of ABO's HandleA is depicted on the right.
	384
51.1	385	(% class="wrapped" %)
4.1	386	\|(((
51.1	387	(% class="content-wrapper" %)
	388	(((
4.1	389	{{code}}
	390	scchart ABO_norm_HandleA {
	391	input output bool A;
	392	input output bool B;
	393	output bool O1;
	394	output bool O2;
	395	region HandleA:
	396	initial state WaitA
	397	--> _S immediate with A
	398	--> _Pause immediate;
	399	final state DoneA;
	400	state _S
	401	--> _S2 immediate with / B = true;
	402	state _S2
	403	--> DoneA immediate with / O1 = true;
	404	state _Pause
	405	--> _Depth;
	406	state _Depth
	407	--> _S immediate with A
	408	--> _Pause immediate;
	409	}
	410	{{/code}}
51.1	411	)))
4.1	412	)))\|(((
51.1	413	(% class="content-wrapper" %)
	414	(((
4.1	415	[[image:attach:abo_norm_HandleA.png]]
51.1	416	)))
4.1	417	)))\|(% colspan="1" %)(% colspan="1" %)
	418	(((
51.1	419	(% class="content-wrapper" %)
	420	(((
4.1	421	[[image:attach:abo_scg_HandleA.png]]
	422	)))
51.1	423	)))
4.1	424
	425	The next figure depicts the direct mapping from normalized SCCharts to their corresponding SCG.
	426
22.1	427	Inspect the metamodel of the SCGs in plugin de.cau.cs.kieler.scg. SCGs are used for analyses and optimization and include a lot of additional elements. However, for this tutorial it should be sufficient to look at the SCGraph class, its nodes attribute, the important node classes and the controlflow class. Important nodes for this SCG are entry, exit, assignment, conditional,
	428
4.1	429	[[image:attach:sccharts-scg.png]]
	430
22.1	431	==== Transformation Creation Task 2 ====
4.1	432
	433	Write a transformation that transforms your normalized version of ABO's HandleA into its corresponding SCG.
	434
48.1	435	* Proceed as before. Create a new plugin (or copy your last one) Make sure, you also add de.cau.cs.kieler.scg to your dependencies.
	436	* Write a transformation that is able to transform {{code language="none"}}ABO_norm_HandleA{{/code}} into its corresponding SCG.
	437	* Verify your generated SCG. If you added your transformation correctly, the SCG should be displayed automatically as soon as selected. If your SCG looks like the SCG depicted earlier, then everything is fine.
	438	* Check your SCG semantically. Is there anything you could improve/optimize?
	439	*1. Write a second transformation (just as before) and add it to the transformation chain right after the transformation you already added.
	440	*1. Optimize the given SCG and compare the result with the previous one.
	441	*1. Make sure that the two SCGs are still semantically identical.
4.1	442
51.1	443	\\
25.1	444
4.1	445	Congratulations! You finished the SCCharts Development Tutorial. Ask your supervisor for further instructions!
	446
51.1	447	\\

Wiki source code of SCCharts Development

Navigation

Quick Links