diff --git a/tooling/org.eclipse.smila.processing.designer.model/.classpath b/tooling/org.eclipse.smila.processing.designer.model/.classpath
index cef6295..8859f25 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/.classpath
+++ b/tooling/org.eclipse.smila.processing.designer.model/.classpath
@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="code/src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="output" path="code/bin"/>
-</classpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="code/src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="output" path="code/bin"/>
+</classpath>
diff --git a/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.core.prefs b/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.core.prefs
index 6a54e88..b1bc3d3 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.core.prefs
+++ b/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.core.prefs
@@ -1,4 +1,4 @@
-#Wed Dec 08 11:07:46 CET 2010
+#Tue Mar 08 09:26:18 CET 2011
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
@@ -19,9 +19,9 @@
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
 org.eclipse.jdt.core.formatter.alignment_for_assignment=16
 org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=52
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16
 org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
 org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
 org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
@@ -35,7 +35,7 @@
 org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
 org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
 org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_field=1
 org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
 org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
 org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
@@ -43,36 +43,36 @@
 org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
 org.eclipse.jdt.core.formatter.blank_lines_before_package=0
 org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=0
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=next_line
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
 org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=next_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true
-org.eclipse.jdt.core.formatter.comment.format_block_comments=false
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=false
-org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=false
-org.eclipse.jdt.core.formatter.comment.format_line_comments=false
-org.eclipse.jdt.core.formatter.comment.format_source_code=false
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=true
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
 org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=false
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
 org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
-org.eclipse.jdt.core.formatter.comment.line_length=256
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=120
 org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
 org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
 org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.continuation_indentation=1
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=1
 org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
 org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
 org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
@@ -87,17 +87,17 @@
 org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
 org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
 org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.indentation.size=2
 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
@@ -143,7 +143,7 @@
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
@@ -172,7 +172,7 @@
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
@@ -189,11 +189,11 @@
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
@@ -266,14 +266,14 @@
 org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
 org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
 org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=128
+org.eclipse.jdt.core.formatter.lineSplit=116
 org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
 org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=false
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
 org.eclipse.jdt.core.formatter.tabulation.char=space
-org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.tabulation.size=2
 org.eclipse.jdt.core.formatter.use_on_off_tags=false
 org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
 org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
diff --git a/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.ui.prefs b/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.ui.prefs
index 2dbef39..7c3205b 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.ui.prefs
+++ b/tooling/org.eclipse.smila.processing.designer.model/.settings/org.eclipse.jdt.ui.prefs
@@ -1,4 +1,4 @@
-#Fri Dec 10 15:41:54 CET 2010
+#Tue Mar 08 09:26:18 CET 2011
 cleanup.add_default_serial_version_id=true
 cleanup.add_generated_serial_version_id=false
 cleanup.add_missing_annotations=true
@@ -54,7 +54,7 @@
 cleanup_settings_version=2
 eclipse.preferences.version=1
 editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
-formatter_profile=_empolis
+formatter_profile=_Eclipse - Brox
 formatter_settings_version=11
 org.eclipse.jdt.ui.ignorelowercasenames=false
 org.eclipse.jdt.ui.importorder=java;javax;org;com;
diff --git a/tooling/org.eclipse.smila.processing.designer.model/META-INF/MANIFEST.MF b/tooling/org.eclipse.smila.processing.designer.model/META-INF/MANIFEST.MF
index 39626e3..720ede1 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/META-INF/MANIFEST.MF
+++ b/tooling/org.eclipse.smila.processing.designer.model/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.smila.processing.designer.model;singleton:=true
-Bundle-Version: 0.1.0
+Bundle-Version: 0.8.0
 Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
@@ -18,6 +18,5 @@
  org.eclipse.bpel.model;visibility:=reexport,
  org.eclipse.wst.wsdl;visibility:=reexport,
  org.eclipse.xsd;visibility:=reexport,
- javax.wsdl;bundle-version="[1.5.0,1.6.0)",
- org.junit4;bundle-version="4.8.1"
+ javax.wsdl;bundle-version="[1.5.0,1.6.0)"
 Bundle-ActivationPolicy: lazy
diff --git a/tooling/org.eclipse.smila.processing.designer.model/about.html b/tooling/org.eclipse.smila.processing.designer.model/about.html
index 910ad79..d8dfe9d 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/about.html
+++ b/tooling/org.eclipse.smila.processing.designer.model/about.html
@@ -1,28 +1,28 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
-<title>About</title>
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>Apr 28, 2008</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was 
-provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content
-and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
-
-</body>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>Apr 28, 2008</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
+
+</body>
 </html>
\ No newline at end of file
diff --git a/tooling/org.eclipse.smila.processing.designer.model/build.properties b/tooling/org.eclipse.smila.processing.designer.model/build.properties
index 5deab49..00876d7 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/build.properties
+++ b/tooling/org.eclipse.smila.processing.designer.model/build.properties
@@ -12,4 +12,4 @@
                plugin.properties
 jars.compile.order = .
 source.. = code/src/
-output.. = code/bin/
+output.. = bin/
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Configuration.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Configuration.java
new file mode 100644
index 0000000..8c224f6
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Configuration.java
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.processor;
+
+import org.eclipse.smila.processing.designer.model.record.RecordMap;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Configuration</b></em>'. <!-- end-user-doc -->
+ * 
+ * 
+ * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getConfiguration()
+ * @model
+ * @generated
+ */
+public interface Configuration extends RecordMap {
+} // Configuration
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokePipelet.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokePipelet.java
index dfa06f9..6152f16 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokePipelet.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokePipelet.java
@@ -1,76 +1,110 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor;
 
 import org.eclipse.bpel.model.ExtensionActivity;
+import org.eclipse.smila.processing.designer.model.record.ExtensionElement;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Invoke Pipelet</b></em>'.
- * <!-- end-user-doc -->
- *
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Invoke Pipelet</b></em>'. <!-- end-user-doc -->
+ * 
  * <p>
  * The following features are supported:
  * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet <em>Pipelet</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables <em>Variables</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipeletConfiguration <em>Pipelet Configuration</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet <em>Pipelet</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables <em>Variables</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getConfiguration <em>Configuration
+ * </em>}</li>
  * </ul>
  * </p>
- *
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet()
  * @model
  * @generated
  */
-public interface InvokePipelet extends ExtensionActivity
-{
-    /**
-     * Returns the value of the '<em><b>Pipelet</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Pipelet</em>' containment reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Pipelet</em>' containment reference.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet_Pipelet()
-     * @model containment="true" required="true" changeable="false" ordered="false"
-     * @generated
-     */
-    Pipelet getPipelet();
+public interface InvokePipelet extends ExtensionActivity, ExtensionElement {
+  /**
+   * Returns the value of the '<em><b>Pipelet</b></em>' containment reference. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Pipelet</em>' containment reference isn't clear, there really should be more of a
+   * description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Pipelet</em>' containment reference.
+   * @see #setPipelet(Pipelet)
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet_Pipelet()
+   * @model containment="true" required="true"
+   * @generated
+   */
+  Pipelet getPipelet();
 
-    /**
-     * Returns the value of the '<em><b>Variables</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Variables</em>' containment reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Variables</em>' containment reference.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet_Variables()
-     * @model containment="true" required="true" changeable="false" ordered="false"
-     * @generated
-     */
-    Variables getVariables();
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet
+   * <em>Pipelet</em>}' containment reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Pipelet</em>' containment reference.
+   * @see #getPipelet()
+   * @generated
+   */
+  void setPipelet(Pipelet value);
 
-    /**
-     * Returns the value of the '<em><b>Pipelet Configuration</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Pipelet Configuration</em>' containment reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Pipelet Configuration</em>' containment reference.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet_PipeletConfiguration()
-     * @model containment="true" required="true" changeable="false" ordered="false"
-     * @generated
-     */
-    PipeletConfiguration getPipeletConfiguration();
+  /**
+   * Returns the value of the '<em><b>Variables</b></em>' containment reference. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Variables</em>' containment reference isn't clear, there really should be more of a
+   * description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Variables</em>' containment reference.
+   * @see #setVariables(Variables)
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet_Variables()
+   * @model containment="true" required="true"
+   * @generated
+   */
+  Variables getVariables();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables
+   * <em>Variables</em>}' containment reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Variables</em>' containment reference.
+   * @see #getVariables()
+   * @generated
+   */
+  void setVariables(Variables value);
+
+  /**
+   * Returns the value of the '<em><b>Configuration</b></em>' containment reference. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Configuration</em>' containment reference isn't clear, there really should be more of a
+   * description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Configuration</em>' containment reference.
+   * @see #setConfiguration(Configuration)
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokePipelet_Configuration()
+   * @model containment="true" required="true"
+   * @generated
+   */
+  Configuration getConfiguration();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getConfiguration
+   * <em>Configuration</em>}' containment reference. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Configuration</em>' containment reference.
+   * @see #getConfiguration()
+   * @generated
+   */
+  void setConfiguration(Configuration value);
 
 } // InvokePipelet
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokeService.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokeService.java
deleted file mode 100644
index 12c9ed1..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/InvokeService.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor;
-
-import org.eclipse.bpel.model.ExtensionActivity;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Invoke Service</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokeService#getService <em>Service</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokeService#getVariables <em>Variables</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.InvokeService#getSetAnnotations <em>Set Annotations</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokeService()
- * @model
- * @generated
- */
-public interface InvokeService extends ExtensionActivity
-{
-    /**
-     * Returns the value of the '<em><b>Service</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Service</em>' containment reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Service</em>' containment reference.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokeService_Service()
-     * @model containment="true" required="true" changeable="false" ordered="false"
-     * @generated
-     */
-    Service getService();
-
-    /**
-     * Returns the value of the '<em><b>Variables</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Variables</em>' containment reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Variables</em>' containment reference.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokeService_Variables()
-     * @model containment="true" required="true" changeable="false" ordered="false"
-     * @generated
-     */
-    Variables getVariables();
-
-    /**
-     * Returns the value of the '<em><b>Set Annotations</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Set Annotations</em>' reference isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Set Annotations</em>' containment reference.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getInvokeService_SetAnnotations()
-     * @model containment="true" changeable="false"
-     * @generated
-     */
-    SetAnnotations getSetAnnotations();
-
-} // InvokeService
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Pipelet.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Pipelet.java
index 5e69df4..f0fafe0 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Pipelet.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Pipelet.java
@@ -1,55 +1,51 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor;
 
-import org.eclipse.bpel.model.ExtensibleElement;
+import org.eclipse.smila.processing.designer.model.record.ExtensionElement;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pipelet</b></em>'.
- * <!-- end-user-doc -->
- *
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Pipelet</b></em>'. <!-- end-user-doc -->
+ * 
  * <p>
  * The following features are supported:
  * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_ <em>Class</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_ <em>Class</em>}</li>
  * </ul>
  * </p>
- *
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getPipelet()
  * @model
  * @generated
  */
-public interface Pipelet extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Class</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Class</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Class</em>' attribute.
-     * @see #setClass(String)
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getPipelet_Class()
-     * @model required="true"
-     * @generated
-     */
-    String getClass_();
+public interface Pipelet extends ExtensionElement {
+  /**
+   * Returns the value of the '<em><b>Class</b></em>' attribute. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Class</em>' attribute isn't clear, there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Class</em>' attribute.
+   * @see #setClass(String)
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getPipelet_Class()
+   * @model required="true"
+   * @generated
+   */
+  String getClass_();
 
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_ <em>Class</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Class</em>' attribute.
-     * @see #getClass_()
-     * @generated
-     */
-    void setClass(String value);
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_
+   * <em>Class</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Class</em>' attribute.
+   * @see #getClass_()
+   * @generated
+   */
+  void setClass(String value);
 
 } // Pipelet
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/PipeletConfiguration.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/PipeletConfiguration.java
deleted file mode 100644
index 89cb90a..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/PipeletConfiguration.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor;
-
-import org.eclipse.bpel.model.ExtensibleElement;
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Pipelet Configuration</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration#getProperties <em>Properties</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getPipeletConfiguration()
- * @model
- * @generated
- */
-public interface PipeletConfiguration extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Properties</b></em>' containment reference list.
-     * The list contents are of type {@link org.eclipse.smila.processing.designer.model.processor.Property}.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Properties</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Properties</em>' containment reference list.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getPipeletConfiguration_Properties()
-     * @model containment="true"
-     * @generated
-     */
-    EList<Property> getProperties();
-
-} // PipeletConfiguration
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorFactory.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorFactory.java
index 79bb797..6d2e5f6 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorFactory.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorFactory.java
@@ -1,110 +1,66 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor;
 
 import org.eclipse.emf.ecore.EFactory;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Factory</b> for the model. It provides a create method for each non-abstract class of
+ * the model. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage
  * @generated
  */
-public interface ProcessorFactory extends EFactory
-{
-    /**
-     * The singleton instance of the factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    ProcessorFactory eINSTANCE = org.eclipse.smila.processing.designer.model.processor.impl.ProcessorFactoryImpl.init();
+public interface ProcessorFactory extends EFactory {
+  /**
+   * The singleton instance of the factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  ProcessorFactory eINSTANCE = org.eclipse.smila.processing.designer.model.processor.impl.ProcessorFactoryImpl
+    .init();
 
-    /**
-     * Returns a new object of class '<em>Invoke Pipelet</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Invoke Pipelet</em>'.
-     * @generated
-     */
-    InvokePipelet createInvokePipelet();
+  /**
+   * Returns a new object of class '<em>Invoke Pipelet</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Invoke Pipelet</em>'.
+   * @generated
+   */
+  InvokePipelet createInvokePipelet();
 
-    /**
-     * Returns a new object of class '<em>Pipelet</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Pipelet</em>'.
-     * @generated
-     */
-    Pipelet createPipelet();
+  /**
+   * Returns a new object of class '<em>Pipelet</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Pipelet</em>'.
+   * @generated
+   */
+  Pipelet createPipelet();
 
-    /**
-     * Returns a new object of class '<em>Variables</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Variables</em>'.
-     * @generated
-     */
-    Variables createVariables();
+  /**
+   * Returns a new object of class '<em>Variables</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Variables</em>'.
+   * @generated
+   */
+  Variables createVariables();
 
-    /**
-     * Returns a new object of class '<em>Property</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Property</em>'.
-     * @generated
-     */
-    Property createProperty();
+  /**
+   * Returns a new object of class '<em>Configuration</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Configuration</em>'.
+   * @generated
+   */
+  Configuration createConfiguration();
 
-    /**
-     * Returns a new object of class '<em>Pipelet Configuration</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Pipelet Configuration</em>'.
-     * @generated
-     */
-    PipeletConfiguration createPipeletConfiguration();
+  /**
+   * Returns the package supported by this factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the package supported by this factory.
+   * @generated
+   */
+  ProcessorPackage getProcessorPackage();
 
-    /**
-     * Returns a new object of class '<em>Invoke Service</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Invoke Service</em>'.
-     * @generated
-     */
-    InvokeService createInvokeService();
-
-    /**
-     * Returns a new object of class '<em>Service</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Service</em>'.
-     * @generated
-     */
-    Service createService();
-
-    /**
-     * Returns a new object of class '<em>Set Annotations</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Set Annotations</em>'.
-     * @generated
-     */
-    SetAnnotations createSetAnnotations();
-
-    /**
-     * Returns the package supported by this factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the package supported by this factory.
-     * @generated
-     */
-    ProcessorPackage getProcessorPackage();
-
-} //ProcessorFactory
+} // ProcessorFactory
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorPackage.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorPackage.java
index 58c03e6..06080e3 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorPackage.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/ProcessorPackage.java
@@ -1,1150 +1,598 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor;
 
 import org.eclipse.bpel.model.BPELPackage;
 import org.eclipse.emf.ecore.*;
+import org.eclipse.smila.processing.designer.model.record.RecordPackage;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
+ * <!-- begin-user-doc --> The <b>Package</b> for the model. It contains accessors for the meta objects to represent
  * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
+ * <li>each class,</li>
+ * <li>each feature of each class,</li>
+ * <li>each enum,</li>
+ * <li>and each data type</li>
  * </ul>
  * <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorFactory
  * @model kind="package"
  * @generated
  */
-public interface ProcessorPackage extends EPackage
-{
-    /**
-     * The package name.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    String eNAME = "processor";
+public interface ProcessorPackage extends EPackage {
+  /**
+   * The package name. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  String eNAME = "processor";
 
-    /**
-     * The package namespace URI.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    String eNS_URI = "http://www.eclipse.org/smila/processor";
+  /**
+   * The package namespace URI. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  String eNS_URI = "http://www.eclipse.org/smila/processor";
 
-    /**
-     * The package namespace name.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    String eNS_PREFIX = "proc";
+  /**
+   * The package namespace name. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  String eNS_PREFIX = "proc";
 
-    /**
-     * The singleton instance of the package.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    ProcessorPackage eINSTANCE = org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl.init();
+  /**
+   * The singleton instance of the package. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  ProcessorPackage eINSTANCE = org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl
+    .init();
 
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl
+   * <em>Invoke Pipelet</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getInvokePipelet()
+   * @generated
+   */
+  int INVOKE_PIPELET = 0;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSION_ACTIVITY__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__ELEMENT = BPELPackage.EXTENSION_ACTIVITY__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSION_ACTIVITY__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__DOCUMENTATION = BPELPackage.EXTENSION_ACTIVITY__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Name</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__NAME = BPELPackage.EXTENSION_ACTIVITY__NAME;
+
+  /**
+   * The feature id for the '<em><b>Suppress Join Failure</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__SUPPRESS_JOIN_FAILURE = BPELPackage.EXTENSION_ACTIVITY__SUPPRESS_JOIN_FAILURE;
+
+  /**
+   * The feature id for the '<em><b>Targets</b></em>' containment reference. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__TARGETS = BPELPackage.EXTENSION_ACTIVITY__TARGETS;
+
+  /**
+   * The feature id for the '<em><b>Sources</b></em>' containment reference. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__SOURCES = BPELPackage.EXTENSION_ACTIVITY__SOURCES;
+
+  /**
+   * The feature id for the '<em><b>Pipelet</b></em>' containment reference. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__PIPELET = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 0;
+
+  /**
+   * The feature id for the '<em><b>Variables</b></em>' containment reference. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__VARIABLES = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 1;
+
+  /**
+   * The feature id for the '<em><b>Configuration</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET__CONFIGURATION = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 2;
+
+  /**
+   * The number of structural features of the '<em>Invoke Pipelet</em>' class. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int INVOKE_PIPELET_FEATURE_COUNT = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 3;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl
+   * <em>Pipelet</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getPipelet()
+   * @generated
+   */
+  int PIPELET = 1;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int PIPELET__DOCUMENTATION_ELEMENT = RecordPackage.EXTENSION_ELEMENT__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int PIPELET__ELEMENT = RecordPackage.EXTENSION_ELEMENT__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int PIPELET__EEXTENSIBILITY_ELEMENTS = RecordPackage.EXTENSION_ELEMENT__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int PIPELET__DOCUMENTATION = RecordPackage.EXTENSION_ELEMENT__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Class</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int PIPELET__CLASS = RecordPackage.EXTENSION_ELEMENT_FEATURE_COUNT + 0;
+
+  /**
+   * The number of structural features of the '<em>Pipelet</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int PIPELET_FEATURE_COUNT = RecordPackage.EXTENSION_ELEMENT_FEATURE_COUNT + 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl
+   * <em>Variables</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getVariables()
+   * @generated
+   */
+  int VARIABLES = 2;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES__DOCUMENTATION_ELEMENT = RecordPackage.EXTENSION_ELEMENT__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES__ELEMENT = RecordPackage.EXTENSION_ELEMENT__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES__EEXTENSIBILITY_ELEMENTS = RecordPackage.EXTENSION_ELEMENT__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES__DOCUMENTATION = RecordPackage.EXTENSION_ELEMENT__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Input</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES__INPUT = RecordPackage.EXTENSION_ELEMENT_FEATURE_COUNT + 0;
+
+  /**
+   * The feature id for the '<em><b>Output</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES__OUTPUT = RecordPackage.EXTENSION_ELEMENT_FEATURE_COUNT + 1;
+
+  /**
+   * The number of structural features of the '<em>Variables</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int VARIABLES_FEATURE_COUNT = RecordPackage.EXTENSION_ELEMENT_FEATURE_COUNT + 2;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.ConfigurationImpl
+   * <em>Configuration</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.ConfigurationImpl
+   * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getConfiguration()
+   * @generated
+   */
+  int CONFIGURATION = 3;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION__DOCUMENTATION_ELEMENT = RecordPackage.RECORD_MAP__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION__ELEMENT = RecordPackage.RECORD_MAP__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION__EEXTENSIBILITY_ELEMENTS = RecordPackage.RECORD_MAP__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION__DOCUMENTATION = RecordPackage.RECORD_MAP__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION__KEY = RecordPackage.RECORD_MAP__KEY;
+
+  /**
+   * The feature id for the '<em><b>Values</b></em>' containment reference list. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION__VALUES = RecordPackage.RECORD_MAP__VALUES;
+
+  /**
+   * The number of structural features of the '<em>Configuration</em>' class. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int CONFIGURATION_FEATURE_COUNT = RecordPackage.RECORD_MAP_FEATURE_COUNT + 0;
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet
+   * <em>Invoke Pipelet</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Invoke Pipelet</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet
+   * @generated
+   */
+  EClass getInvokePipelet();
+
+  /**
+   * Returns the meta object for the containment reference '
+   * {@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet <em>Pipelet</em>}'. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the containment reference '<em>Pipelet</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet()
+   * @see #getInvokePipelet()
+   * @generated
+   */
+  EReference getInvokePipelet_Pipelet();
+
+  /**
+   * Returns the meta object for the containment reference '
+   * {@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables <em>Variables</em>}'. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the containment reference '<em>Variables</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables()
+   * @see #getInvokePipelet()
+   * @generated
+   */
+  EReference getInvokePipelet_Variables();
+
+  /**
+   * Returns the meta object for the containment reference '
+   * {@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getConfiguration <em>Configuration</em>}
+   * '. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the containment reference '<em>Configuration</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getConfiguration()
+   * @see #getInvokePipelet()
+   * @generated
+   */
+  EReference getInvokePipelet_Configuration();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet
+   * <em>Pipelet</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Pipelet</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.Pipelet
+   * @generated
+   */
+  EClass getPipelet();
+
+  /**
+   * Returns the meta object for the attribute '
+   * {@link org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_ <em>Class</em>}'. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the attribute '<em>Class</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_()
+   * @see #getPipelet()
+   * @generated
+   */
+  EAttribute getPipelet_Class();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Variables
+   * <em>Variables</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Variables</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.Variables
+   * @generated
+   */
+  EClass getVariables();
+
+  /**
+   * Returns the meta object for the attribute '
+   * {@link org.eclipse.smila.processing.designer.model.processor.Variables#getInput <em>Input</em>}'. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the attribute '<em>Input</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.Variables#getInput()
+   * @see #getVariables()
+   * @generated
+   */
+  EAttribute getVariables_Input();
+
+  /**
+   * Returns the meta object for the attribute '
+   * {@link org.eclipse.smila.processing.designer.model.processor.Variables#getOutput <em>Output</em>}'. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the attribute '<em>Output</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.Variables#getOutput()
+   * @see #getVariables()
+   * @generated
+   */
+  EAttribute getVariables_Output();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Configuration
+   * <em>Configuration</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Configuration</em>'.
+   * @see org.eclipse.smila.processing.designer.model.processor.Configuration
+   * @generated
+   */
+  EClass getConfiguration();
+
+  /**
+   * Returns the factory that creates the instances of the model. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the factory that creates the instances of the model.
+   * @generated
+   */
+  ProcessorFactory getProcessorFactory();
+
+  /**
+   * <!-- begin-user-doc --> Defines literals for the meta objects that represent
+   * <ul>
+   * <li>each class,</li>
+   * <li>each feature of each class,</li>
+   * <li>each enum,</li>
+   * <li>and each data type</li>
+   * </ul>
+   * <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  interface Literals {
     /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl <em>Invoke Pipelet</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '
+     * {@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl <em>Invoke Pipelet</em>}'
+     * class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
      * @see org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl
      * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getInvokePipelet()
      * @generated
      */
-    int INVOKE_PIPELET = 0;
+    EClass INVOKE_PIPELET = eINSTANCE.getInvokePipelet();
 
     /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
+     * The meta object literal for the '<em><b>Pipelet</b></em>' containment reference feature. <!-- begin-user-doc -->
      * <!-- end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int INVOKE_PIPELET__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSION_ACTIVITY__DOCUMENTATION_ELEMENT;
+    EReference INVOKE_PIPELET__PIPELET = eINSTANCE.getInvokePipelet_Pipelet();
 
     /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Variables</b></em>' containment reference feature. <!-- begin-user-doc
+     * --> <!-- end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int INVOKE_PIPELET__ELEMENT = BPELPackage.EXTENSION_ACTIVITY__ELEMENT;
+    EReference INVOKE_PIPELET__VARIABLES = eINSTANCE.getInvokePipelet_Variables();
 
     /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Configuration</b></em>' containment reference feature. <!--
+     * begin-user-doc --> <!-- end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int INVOKE_PIPELET__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSION_ACTIVITY__EEXTENSIBILITY_ELEMENTS;
+    EReference INVOKE_PIPELET__CONFIGURATION = eINSTANCE.getInvokePipelet_Configuration();
 
     /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__DOCUMENTATION = BPELPackage.EXTENSION_ACTIVITY__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__NAME = BPELPackage.EXTENSION_ACTIVITY__NAME;
-
-    /**
-     * The feature id for the '<em><b>Suppress Join Failure</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__SUPPRESS_JOIN_FAILURE = BPELPackage.EXTENSION_ACTIVITY__SUPPRESS_JOIN_FAILURE;
-
-    /**
-     * The feature id for the '<em><b>Targets</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__TARGETS = BPELPackage.EXTENSION_ACTIVITY__TARGETS;
-
-    /**
-     * The feature id for the '<em><b>Sources</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__SOURCES = BPELPackage.EXTENSION_ACTIVITY__SOURCES;
-
-    /**
-     * The feature id for the '<em><b>Pipelet</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__PIPELET = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 0;
-
-    /**
-     * The feature id for the '<em><b>Variables</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__VARIABLES = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 1;
-
-    /**
-     * The feature id for the '<em><b>Pipelet Configuration</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET__PIPELET_CONFIGURATION = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 2;
-
-    /**
-     * The number of structural features of the '<em>Invoke Pipelet</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_PIPELET_FEATURE_COUNT = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 3;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl <em>Pipelet</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl
+     * <em>Pipelet</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
      * @see org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl
      * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getPipelet()
      * @generated
      */
-    int PIPELET = 1;
+    EClass PIPELET = eINSTANCE.getPipelet();
 
     /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Class</b></em>' attribute feature. <!-- begin-user-doc --> <!--
+     * end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int PIPELET__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
+    EAttribute PIPELET__CLASS = eINSTANCE.getPipelet_Class();
 
     /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Class</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET__CLASS = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The number of structural features of the '<em>Pipelet</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl <em>Variables</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl
+     * <em>Variables</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
      * @see org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl
      * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getVariables()
      * @generated
      */
-    int VARIABLES = 2;
+    EClass VARIABLES = eINSTANCE.getVariables();
 
     /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Input</b></em>' attribute feature. <!-- begin-user-doc --> <!--
+     * end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int VARIABLES__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
+    EAttribute VARIABLES__INPUT = eINSTANCE.getVariables_Input();
 
     /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Output</b></em>' attribute feature. <!-- begin-user-doc --> <!--
+     * end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int VARIABLES__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
+    EAttribute VARIABLES__OUTPUT = eINSTANCE.getVariables_Output();
 
     /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
+     * The meta object literal for the '
+     * {@link org.eclipse.smila.processing.designer.model.processor.impl.ConfigurationImpl <em>Configuration</em>}'
+     * class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.processor.impl.ConfigurationImpl
+     * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getConfiguration()
      * @generated
-     * @ordered
      */
-    int VARIABLES__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
+    EClass CONFIGURATION = eINSTANCE.getConfiguration();
 
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int VARIABLES__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
+  }
 
-    /**
-     * The feature id for the '<em><b>Input</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int VARIABLES__INPUT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The feature id for the '<em><b>Output</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int VARIABLES__OUTPUT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The number of structural features of the '<em>Variables</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int VARIABLES_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 2;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PropertyImpl <em>Property</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.PropertyImpl
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getProperty()
-     * @generated
-     */
-    int PROPERTY = 3;
-
-    /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY__NAME = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The feature id for the '<em><b>Value</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY__VALUE = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The number of structural features of the '<em>Property</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PROPERTY_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 2;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletConfigurationImpl <em>Pipelet Configuration</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.PipeletConfigurationImpl
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getPipeletConfiguration()
-     * @generated
-     */
-    int PIPELET_CONFIGURATION = 4;
-
-    /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_CONFIGURATION__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_CONFIGURATION__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_CONFIGURATION__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_CONFIGURATION__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Properties</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_CONFIGURATION__PROPERTIES = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The number of structural features of the '<em>Pipelet Configuration</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int PIPELET_CONFIGURATION_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl <em>Invoke Service</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getInvokeService()
-     * @generated
-     */
-    int INVOKE_SERVICE = 5;
-
-    /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSION_ACTIVITY__DOCUMENTATION_ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__ELEMENT = BPELPackage.EXTENSION_ACTIVITY__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSION_ACTIVITY__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__DOCUMENTATION = BPELPackage.EXTENSION_ACTIVITY__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__NAME = BPELPackage.EXTENSION_ACTIVITY__NAME;
-
-    /**
-     * The feature id for the '<em><b>Suppress Join Failure</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__SUPPRESS_JOIN_FAILURE = BPELPackage.EXTENSION_ACTIVITY__SUPPRESS_JOIN_FAILURE;
-
-    /**
-     * The feature id for the '<em><b>Targets</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__TARGETS = BPELPackage.EXTENSION_ACTIVITY__TARGETS;
-
-    /**
-     * The feature id for the '<em><b>Sources</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__SOURCES = BPELPackage.EXTENSION_ACTIVITY__SOURCES;
-
-    /**
-     * The feature id for the '<em><b>Service</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__SERVICE = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 0;
-
-    /**
-     * The feature id for the '<em><b>Variables</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__VARIABLES = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 1;
-
-    /**
-     * The feature id for the '<em><b>Set Annotations</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE__SET_ANNOTATIONS = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 2;
-
-    /**
-     * The number of structural features of the '<em>Invoke Service</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int INVOKE_SERVICE_FEATURE_COUNT = BPELPackage.EXTENSION_ACTIVITY_FEATURE_COUNT + 3;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.ServiceImpl <em>Service</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.ServiceImpl
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getService()
-     * @generated
-     */
-    int SERVICE = 6;
-
-    /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SERVICE__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SERVICE__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SERVICE__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SERVICE__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SERVICE__NAME = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The number of structural features of the '<em>Service</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SERVICE_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.SetAnnotationsImpl <em>Set Annotations</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.SetAnnotationsImpl
-     * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getSetAnnotations()
-     * @generated
-     */
-    int SET_ANNOTATIONS = 7;
-
-    /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SET_ANNOTATIONS__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SET_ANNOTATIONS__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SET_ANNOTATIONS__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SET_ANNOTATIONS__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Annotations</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SET_ANNOTATIONS__ANNOTATIONS = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The number of structural features of the '<em>Set Annotations</em>' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int SET_ANNOTATIONS_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet <em>Invoke Pipelet</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Invoke Pipelet</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet
-     * @generated
-     */
-    EClass getInvokePipelet();
-
-    /**
-     * Returns the meta object for the containment reference '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet <em>Pipelet</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference '<em>Pipelet</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipelet()
-     * @see #getInvokePipelet()
-     * @generated
-     */
-    EReference getInvokePipelet_Pipelet();
-
-    /**
-     * Returns the meta object for the containment reference '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables <em>Variables</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference '<em>Variables</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getVariables()
-     * @see #getInvokePipelet()
-     * @generated
-     */
-    EReference getInvokePipelet_Variables();
-
-    /**
-     * Returns the meta object for the containment reference '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipeletConfiguration <em>Pipelet Configuration</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference '<em>Pipelet Configuration</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet#getPipeletConfiguration()
-     * @see #getInvokePipelet()
-     * @generated
-     */
-    EReference getInvokePipelet_PipeletConfiguration();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet <em>Pipelet</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Pipelet</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Pipelet
-     * @generated
-     */
-    EClass getPipelet();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_ <em>Class</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Class</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Pipelet#getClass_()
-     * @see #getPipelet()
-     * @generated
-     */
-    EAttribute getPipelet_Class();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Variables <em>Variables</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Variables</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Variables
-     * @generated
-     */
-    EClass getVariables();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.processor.Variables#getInput <em>Input</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Input</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Variables#getInput()
-     * @see #getVariables()
-     * @generated
-     */
-    EAttribute getVariables_Input();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.processor.Variables#getOutput <em>Output</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Output</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Variables#getOutput()
-     * @see #getVariables()
-     * @generated
-     */
-    EAttribute getVariables_Output();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Property <em>Property</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Property</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Property
-     * @generated
-     */
-    EClass getProperty();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.processor.Property#getName <em>Name</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Name</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Property#getName()
-     * @see #getProperty()
-     * @generated
-     */
-    EAttribute getProperty_Name();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.processor.Property#getValue <em>Value</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Value</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Property#getValue()
-     * @see #getProperty()
-     * @generated
-     */
-    EAttribute getProperty_Value();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration <em>Pipelet Configuration</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Pipelet Configuration</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration
-     * @generated
-     */
-    EClass getPipeletConfiguration();
-
-    /**
-     * Returns the meta object for the containment reference list '{@link org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration#getProperties <em>Properties</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference list '<em>Properties</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration#getProperties()
-     * @see #getPipeletConfiguration()
-     * @generated
-     */
-    EReference getPipeletConfiguration_Properties();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.InvokeService <em>Invoke Service</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Invoke Service</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokeService
-     * @generated
-     */
-    EClass getInvokeService();
-
-    /**
-     * Returns the meta object for the containment reference '{@link org.eclipse.smila.processing.designer.model.processor.InvokeService#getService <em>Service</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference '<em>Service</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokeService#getService()
-     * @see #getInvokeService()
-     * @generated
-     */
-    EReference getInvokeService_Service();
-
-    /**
-     * Returns the meta object for the containment reference '{@link org.eclipse.smila.processing.designer.model.processor.InvokeService#getVariables <em>Variables</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference '<em>Variables</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokeService#getVariables()
-     * @see #getInvokeService()
-     * @generated
-     */
-    EReference getInvokeService_Variables();
-
-    /**
-     * Returns the meta object for the containment reference '{@link org.eclipse.smila.processing.designer.model.processor.InvokeService#getSetAnnotations <em>Set Annotations</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference '<em>Set Annotations</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokeService#getSetAnnotations()
-     * @see #getInvokeService()
-     * @generated
-     */
-    EReference getInvokeService_SetAnnotations();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.Service <em>Service</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Service</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Service
-     * @generated
-     */
-    EClass getService();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.processor.Service#getName <em>Name</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Name</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.Service#getName()
-     * @see #getService()
-     * @generated
-     */
-    EAttribute getService_Name();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.processor.SetAnnotations <em>Set Annotations</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Set Annotations</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.SetAnnotations
-     * @generated
-     */
-    EClass getSetAnnotations();
-
-    /**
-     * Returns the meta object for the containment reference list '{@link org.eclipse.smila.processing.designer.model.processor.SetAnnotations#getAnnotations <em>Annotations</em>}'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the meta object for the containment reference list '<em>Annotations</em>'.
-     * @see org.eclipse.smila.processing.designer.model.processor.SetAnnotations#getAnnotations()
-     * @see #getSetAnnotations()
-     * @generated
-     */
-    EReference getSetAnnotations_Annotations();
-
-    /**
-     * Returns the factory that creates the instances of the model.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the factory that creates the instances of the model.
-     * @generated
-     */
-    ProcessorFactory getProcessorFactory();
-
-    /**
-     * <!-- begin-user-doc -->
-     * Defines literals for the meta objects that represent
-     * <ul>
-     *   <li>each class,</li>
-     *   <li>each feature of each class,</li>
-     *   <li>each enum,</li>
-     *   <li>and each data type</li>
-     * </ul>
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    interface Literals
-    {
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl <em>Invoke Pipelet</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getInvokePipelet()
-         * @generated
-         */
-        EClass INVOKE_PIPELET = eINSTANCE.getInvokePipelet();
-
-        /**
-         * The meta object literal for the '<em><b>Pipelet</b></em>' containment reference feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference INVOKE_PIPELET__PIPELET = eINSTANCE.getInvokePipelet_Pipelet();
-
-        /**
-         * The meta object literal for the '<em><b>Variables</b></em>' containment reference feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference INVOKE_PIPELET__VARIABLES = eINSTANCE.getInvokePipelet_Variables();
-
-        /**
-         * The meta object literal for the '<em><b>Pipelet Configuration</b></em>' containment reference feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference INVOKE_PIPELET__PIPELET_CONFIGURATION = eINSTANCE.getInvokePipelet_PipeletConfiguration();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl <em>Pipelet</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getPipelet()
-         * @generated
-         */
-        EClass PIPELET = eINSTANCE.getPipelet();
-
-        /**
-         * The meta object literal for the '<em><b>Class</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute PIPELET__CLASS = eINSTANCE.getPipelet_Class();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl <em>Variables</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getVariables()
-         * @generated
-         */
-        EClass VARIABLES = eINSTANCE.getVariables();
-
-        /**
-         * The meta object literal for the '<em><b>Input</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute VARIABLES__INPUT = eINSTANCE.getVariables_Input();
-
-        /**
-         * The meta object literal for the '<em><b>Output</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute VARIABLES__OUTPUT = eINSTANCE.getVariables_Output();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PropertyImpl <em>Property</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.PropertyImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getProperty()
-         * @generated
-         */
-        EClass PROPERTY = eINSTANCE.getProperty();
-
-        /**
-         * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute PROPERTY__NAME = eINSTANCE.getProperty_Name();
-
-        /**
-         * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute PROPERTY__VALUE = eINSTANCE.getProperty_Value();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletConfigurationImpl <em>Pipelet Configuration</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.PipeletConfigurationImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getPipeletConfiguration()
-         * @generated
-         */
-        EClass PIPELET_CONFIGURATION = eINSTANCE.getPipeletConfiguration();
-
-        /**
-         * The meta object literal for the '<em><b>Properties</b></em>' containment reference list feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference PIPELET_CONFIGURATION__PROPERTIES = eINSTANCE.getPipeletConfiguration_Properties();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl <em>Invoke Service</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getInvokeService()
-         * @generated
-         */
-        EClass INVOKE_SERVICE = eINSTANCE.getInvokeService();
-
-        /**
-         * The meta object literal for the '<em><b>Service</b></em>' containment reference feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference INVOKE_SERVICE__SERVICE = eINSTANCE.getInvokeService_Service();
-
-        /**
-         * The meta object literal for the '<em><b>Variables</b></em>' containment reference feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference INVOKE_SERVICE__VARIABLES = eINSTANCE.getInvokeService_Variables();
-
-        /**
-         * The meta object literal for the '<em><b>Set Annotations</b></em>' containment reference feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference INVOKE_SERVICE__SET_ANNOTATIONS = eINSTANCE.getInvokeService_SetAnnotations();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.ServiceImpl <em>Service</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ServiceImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getService()
-         * @generated
-         */
-        EClass SERVICE = eINSTANCE.getService();
-
-        /**
-         * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute SERVICE__NAME = eINSTANCE.getService_Name();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.processor.impl.SetAnnotationsImpl <em>Set Annotations</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.SetAnnotationsImpl
-         * @see org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl#getSetAnnotations()
-         * @generated
-         */
-        EClass SET_ANNOTATIONS = eINSTANCE.getSetAnnotations();
-
-        /**
-         * The meta object literal for the '<em><b>Annotations</b></em>' containment reference list feature.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference SET_ANNOTATIONS__ANNOTATIONS = eINSTANCE.getSetAnnotations_Annotations();
-
-    }
-
-} //ProcessorPackage
+} // ProcessorPackage
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Property.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Property.java
deleted file mode 100644
index b5461f0..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Property.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor;
-
-import org.eclipse.bpel.model.ExtensibleElement;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Property</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.Property#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.Property#getValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getProperty()
- * @model
- * @generated
- */
-public interface Property extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Name</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Name</em>' attribute.
-     * @see #setName(String)
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getProperty_Name()
-     * @model required="true"
-     * @generated
-     */
-    String getName();
-
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Property#getName <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Name</em>' attribute.
-     * @see #getName()
-     * @generated
-     */
-    void setName(String value);
-
-    /**
-     * Returns the value of the '<em><b>Value</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Value</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Value</em>' attribute.
-     * @see #setValue(String)
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getProperty_Value()
-     * @model required="true"
-     * @generated
-     */
-    String getValue();
-
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Property#getValue <em>Value</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Value</em>' attribute.
-     * @see #getValue()
-     * @generated
-     */
-    void setValue(String value);
-
-} // Property
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Service.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Service.java
deleted file mode 100644
index 1aee9cd..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Service.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor;
-
-import org.eclipse.bpel.model.ExtensibleElement;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Service</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.Service#getName <em>Name</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getService()
- * @model
- * @generated
- */
-public interface Service extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Name</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Name</em>' attribute.
-     * @see #setName(String)
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getService_Name()
-     * @model required="true"
-     * @generated
-     */
-    String getName();
-
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Service#getName <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Name</em>' attribute.
-     * @see #getName()
-     * @generated
-     */
-    void setName(String value);
-
-} // Service
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/SetAnnotations.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/SetAnnotations.java
deleted file mode 100644
index f807da0..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/SetAnnotations.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor;
-
-import org.eclipse.bpel.model.ExtensibleElement;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.smila.processing.designer.model.record.Annotation;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Set Annotations</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.SetAnnotations#getAnnotations <em>Annotations</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getSetAnnotations()
- * @model
- * @generated
- */
-public interface SetAnnotations extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Annotations</b></em>' containment reference list.
-     * The list contents are of type {@link org.eclipse.smila.processing.designer.model.record.Annotation}.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Annotations</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Annotations</em>' containment reference list.
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getSetAnnotations_Annotations()
-     * @model containment="true"
-     * @generated
-     */
-    EList<Annotation> getAnnotations();
-
-} // SetAnnotations
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Variables.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Variables.java
index 56b0eb9..71de445 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Variables.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/Variables.java
@@ -1,82 +1,78 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor;
 
-import org.eclipse.bpel.model.ExtensibleElement;
+import org.eclipse.smila.processing.designer.model.record.ExtensionElement;
 
 /**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Variables</b></em>'.
- * <!-- end-user-doc -->
- *
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Variables</b></em>'. <!-- end-user-doc -->
+ * 
  * <p>
  * The following features are supported:
  * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.Variables#getInput <em>Input</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.Variables#getOutput <em>Output</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.Variables#getInput <em>Input</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.Variables#getOutput <em>Output</em>}</li>
  * </ul>
  * </p>
- *
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getVariables()
  * @model
  * @generated
  */
-public interface Variables extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Input</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Input</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Input</em>' attribute.
-     * @see #setInput(String)
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getVariables_Input()
-     * @model required="true"
-     * @generated
-     */
-    String getInput();
+public interface Variables extends ExtensionElement {
+  /**
+   * Returns the value of the '<em><b>Input</b></em>' attribute. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Input</em>' attribute isn't clear, there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Input</em>' attribute.
+   * @see #setInput(String)
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getVariables_Input()
+   * @model required="true"
+   * @generated
+   */
+  String getInput();
 
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Variables#getInput <em>Input</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Input</em>' attribute.
-     * @see #getInput()
-     * @generated
-     */
-    void setInput(String value);
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Variables#getInput
+   * <em>Input</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Input</em>' attribute.
+   * @see #getInput()
+   * @generated
+   */
+  void setInput(String value);
 
-    /**
-     * Returns the value of the '<em><b>Output</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Output</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Output</em>' attribute.
-     * @see #setOutput(String)
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getVariables_Output()
-     * @model required="true"
-     * @generated
-     */
-    String getOutput();
+  /**
+   * Returns the value of the '<em><b>Output</b></em>' attribute. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Output</em>' attribute isn't clear, there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Output</em>' attribute.
+   * @see #setOutput(String)
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#getVariables_Output()
+   * @model required="true"
+   * @generated
+   */
+  String getOutput();
 
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Variables#getOutput <em>Output</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Output</em>' attribute.
-     * @see #getOutput()
-     * @generated
-     */
-    void setOutput(String value);
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.processor.Variables#getOutput
+   * <em>Output</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Output</em>' attribute.
+   * @see #getOutput()
+   * @generated
+   */
+  void setOutput(String value);
 
 } // Variables
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ConfigurationImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ConfigurationImpl.java
new file mode 100644
index 0000000..c47f201
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ConfigurationImpl.java
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.processor.impl;
+
+import org.eclipse.bpel.model.util.ReconciliationHelper;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.smila.processing.designer.model.processor.Configuration;
+import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
+import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
+import org.eclipse.smila.processing.designer.model.record.impl.RecordMapImpl;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Configuration</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * </p>
+ * 
+ * @generated
+ */
+public class ConfigurationImpl extends RecordMapImpl implements Configuration {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected ConfigurationImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return ProcessorPackage.Literals.CONFIGURATION;
+  }
+
+  /**
+   * @see RecordMapImpl#createFixedElement(Document)
+   */
+  @Override
+  protected Element createFixedElement(Document document) {
+    Element element = document.createElementNS(ProcessorPackage.eNS_URI, ProcessorConstants.ELEMENT_CONFIGURATION);
+    element.setPrefix(ProcessorPackage.eNS_PREFIX);
+    return createFixedElement(document, element);
+  }
+
+  /**
+   * @see RecordMapImpl#adoptContent(EReference, Object)
+   */
+  @Override
+  protected void adoptContent(EReference reference, Object object) {
+    if (getElement() == null && getContainer() != null && getContainer().getElement() != null && !isReconciling()
+      && !isUpdatingDOM() && !ReconciliationHelper.isLoading(this)) {
+      fixElement(getContainer().getElement().getOwnerDocument());
+    }
+    super.adoptContent(reference, object);
+  }
+
+} // ConfigurationImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokePipeletImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokePipeletImpl.java
index bc03579..0a51244 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokePipeletImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokePipeletImpl.java
@@ -1,13 +1,10 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.impl;
 
-import java.util.List;
-
 import org.eclipse.bpel.model.impl.ExtensionActivityImpl;
 import org.eclipse.bpel.model.util.ReconciliationHelper;
 import org.eclipse.emf.common.notify.Notification;
@@ -18,420 +15,399 @@
 import org.eclipse.smila.processing.designer.model.processor.*;
 import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
 import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
+import org.eclipse.smila.processing.designer.model.record.ExtensionElement;
+import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Invoke Pipelet</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Invoke Pipelet</b></em>'. <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
  * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl#getPipelet <em>Pipelet</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl#getVariables <em>Variables</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl#getPipeletConfiguration <em>Pipelet Configuration</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl#getPipelet <em>Pipelet</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl#getVariables <em>Variables
+ * </em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokePipeletImpl#getConfiguration <em>
+ * Configuration</em>}</li>
  * </ul>
  * </p>
- *
+ * 
  * @generated
  */
-public class InvokePipeletImpl extends ExtensionActivityImpl implements InvokePipelet
-{
-    /**
-     * The cached value of the '{@link #getPipelet() <em>Pipelet</em>}' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getPipelet()
-     * @generated
-     * @ordered
-     */
-    protected Pipelet pipelet;
+public class InvokePipeletImpl extends ExtensionActivityImpl implements InvokePipelet {
+  /**
+   * The cached value of the '{@link #getPipelet() <em>Pipelet</em>}' containment reference. <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * 
+   * @see #getPipelet()
+   * @generated
+   * @ordered
+   */
+  protected Pipelet pipelet;
 
-    /**
-     * The cached value of the '{@link #getVariables() <em>Variables</em>}' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getVariables()
-     * @generated
-     * @ordered
-     */
-    protected Variables variables;
+  /**
+   * The cached value of the '{@link #getVariables() <em>Variables</em>}' containment reference. <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * 
+   * @see #getVariables()
+   * @generated
+   * @ordered
+   */
+  protected Variables variables;
 
-    /**
-     * The cached value of the '{@link #getPipeletConfiguration() <em>Pipelet Configuration</em>}' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getPipeletConfiguration()
-     * @generated
-     * @ordered
-     */
-    protected PipeletConfiguration pipeletConfiguration;
+  /**
+   * The cached value of the '{@link #getConfiguration() <em>Configuration</em>}' containment reference. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see #getConfiguration()
+   * @generated
+   * @ordered
+   */
+  protected Configuration configuration;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    protected InvokePipeletImpl()
-    {
-        setPipelet(ProcessorFactory.eINSTANCE.createPipelet());
-        setVariables(ProcessorFactory.eINSTANCE.createVariables());
-        setPipeletConfiguration(ProcessorFactory.eINSTANCE.createPipeletConfiguration());
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected InvokePipeletImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return ProcessorPackage.Literals.INVOKE_PIPELET;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Pipelet getPipelet() {
+    return pipelet;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  public NotificationChain basicSetPipelet(Pipelet newPipelet, NotificationChain msgs) {
+    Pipelet oldPipelet = pipelet;
+    pipelet = newPipelet;
+
+    // Reconcile
+    replaceChild(oldPipelet, newPipelet);
+
+    if (eNotificationRequired()) {
+      ENotificationImpl notification =
+        new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__PIPELET, oldPipelet,
+          newPipelet);
+      if (msgs == null) {
+        msgs = notification;
+      } else {
+        msgs.add(notification);
+      }
     }
+    return msgs;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.INVOKE_PIPELET;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void setPipelet(Pipelet newPipelet) {
+    if (newPipelet != pipelet) {
+      NotificationChain msgs = null;
+      if (pipelet != null) {
+        msgs =
+          ((InternalEObject) pipelet).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
+            - ProcessorPackage.INVOKE_PIPELET__PIPELET, null, msgs);
+      }
+      if (newPipelet != null) {
+        msgs =
+          ((InternalEObject) newPipelet).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
+            - ProcessorPackage.INVOKE_PIPELET__PIPELET, null, msgs);
+      }
+      msgs = basicSetPipelet(newPipelet, msgs);
+      if (msgs != null) {
+        msgs.dispatch();
+      }
+    } else if (eNotificationRequired()) {
+      eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__PIPELET, newPipelet,
+        newPipelet));
     }
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Pipelet getPipelet()
-    {
-        return pipelet;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Variables getVariables() {
+    return variables;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  public NotificationChain basicSetVariables(Variables newVariables, NotificationChain msgs) {
+    Variables oldVariables = variables;
+    variables = newVariables;
+
+    // Reconcile
+    replaceChild(oldVariables, newVariables);
+
+    if (eNotificationRequired()) {
+      ENotificationImpl notification =
+        new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__VARIABLES, oldVariables,
+          newVariables);
+      if (msgs == null) {
+        msgs = notification;
+      } else {
+        msgs.add(notification);
+      }
     }
+    return msgs;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public NotificationChain basicSetPipelet(Pipelet newPipelet, NotificationChain msgs)
-    {
-        Pipelet oldPipelet = pipelet;
-        pipelet = newPipelet;
-        if (eNotificationRequired())
-        {
-            ENotificationImpl notification =
-                    new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__PIPELET, oldPipelet,
-                            newPipelet);
-            if (msgs == null)
-            {
-                msgs = notification;
-            }
-            else
-            {
-                msgs.add(notification);
-            }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void setVariables(Variables newVariables) {
+    if (newVariables != variables) {
+      NotificationChain msgs = null;
+      if (variables != null) {
+        msgs =
+          ((InternalEObject) variables).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
+            - ProcessorPackage.INVOKE_PIPELET__VARIABLES, null, msgs);
+      }
+      if (newVariables != null) {
+        msgs =
+          ((InternalEObject) newVariables).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
+            - ProcessorPackage.INVOKE_PIPELET__VARIABLES, null, msgs);
+      }
+      msgs = basicSetVariables(newVariables, msgs);
+      if (msgs != null) {
+        msgs.dispatch();
+      }
+    } else if (eNotificationRequired()) {
+      eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__VARIABLES,
+        newVariables, newVariables));
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Configuration getConfiguration() {
+    return configuration;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  public NotificationChain basicSetConfiguration(Configuration newConfiguration, NotificationChain msgs) {
+    Configuration oldConfiguration = configuration;
+    configuration = newConfiguration;
+
+    // Reconcile
+    replaceChild(oldConfiguration, newConfiguration);
+
+    if (eNotificationRequired()) {
+      ENotificationImpl notification =
+        new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__CONFIGURATION,
+          oldConfiguration, newConfiguration);
+      if (msgs == null) {
+        msgs = notification;
+      } else {
+        msgs.add(notification);
+      }
+    }
+    return msgs;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void setConfiguration(Configuration newConfiguration) {
+    if (newConfiguration != configuration) {
+      NotificationChain msgs = null;
+      if (configuration != null) {
+        msgs =
+          ((InternalEObject) configuration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
+            - ProcessorPackage.INVOKE_PIPELET__CONFIGURATION, null, msgs);
+      }
+      if (newConfiguration != null) {
+        msgs =
+          ((InternalEObject) newConfiguration).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
+            - ProcessorPackage.INVOKE_PIPELET__CONFIGURATION, null, msgs);
+      }
+      msgs = basicSetConfiguration(newConfiguration, msgs);
+      if (msgs != null) {
+        msgs.dispatch();
+      }
+    } else if (eNotificationRequired()) {
+      eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__CONFIGURATION,
+        newConfiguration, newConfiguration));
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public Element fixElement(Document document) {
+    if (getElement() == null && !isUpdatingDOM()) {
+      try {
+        setUpdatingDOM(true);
+        Element element =
+          document.createElementNS(ProcessorPackage.eNS_URI, ProcessorConstants.ELEMENT_INVOKE_PIPELET);
+        element.setPrefix(ProcessorPackage.eNS_PREFIX);
+        setElement(element);
+        if (getPipelet() != null) {
+          DOMUtils.appendIndented(element, getPipelet().fixElement(document));
         }
-        return msgs;
+        if (getVariables() != null) {
+          DOMUtils.appendIndented(element, getVariables().fixElement(document));
+        }
+        if (getConfiguration() != null) {
+          DOMUtils.appendIndented(element, getConfiguration().fixElement(document));
+        }
+      } finally {
+        setUpdatingDOM(false);
+      }
     }
+    return getElement();
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    private void setPipelet(Pipelet newPipelet)
-    {
-        if (newPipelet != pipelet)
-        {
-            NotificationChain msgs = null;
-            if (pipelet != null)
-            {
-                msgs =
-                        ((InternalEObject) pipelet).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_PIPELET__PIPELET, null, msgs);
-            }
-            if (newPipelet != null)
-            {
-                msgs =
-                        ((InternalEObject) newPipelet).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_PIPELET__PIPELET, null, msgs);
-            }
-            msgs = basicSetPipelet(newPipelet, msgs);
-            if (msgs != null)
-            {
-                msgs.dispatch();
-            }
-        }
-        else if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__PIPELET, newPipelet,
-                    newPipelet));
-        }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+    switch (featureID) {
+      case ProcessorPackage.INVOKE_PIPELET__PIPELET:
+        return basicSetPipelet(null, msgs);
+      case ProcessorPackage.INVOKE_PIPELET__VARIABLES:
+        return basicSetVariables(null, msgs);
+      case ProcessorPackage.INVOKE_PIPELET__CONFIGURATION:
+        return basicSetConfiguration(null, msgs);
     }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Variables getVariables()
-    {
-        return variables;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+      case ProcessorPackage.INVOKE_PIPELET__PIPELET:
+        return getPipelet();
+      case ProcessorPackage.INVOKE_PIPELET__VARIABLES:
+        return getVariables();
+      case ProcessorPackage.INVOKE_PIPELET__CONFIGURATION:
+        return getConfiguration();
     }
+    return super.eGet(featureID, resolve, coreType);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public NotificationChain basicSetVariables(Variables newVariables, NotificationChain msgs)
-    {
-        Variables oldVariables = variables;
-        variables = newVariables;
-        if (eNotificationRequired())
-        {
-            ENotificationImpl notification =
-                    new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__VARIABLES, oldVariables,
-                            newVariables);
-            if (msgs == null)
-            {
-                msgs = notification;
-            }
-            else
-            {
-                msgs.add(notification);
-            }
-        }
-        return msgs;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue) {
+    switch (featureID) {
+      case ProcessorPackage.INVOKE_PIPELET__PIPELET:
+        setPipelet((Pipelet) newValue);
+        return;
+      case ProcessorPackage.INVOKE_PIPELET__VARIABLES:
+        setVariables((Variables) newValue);
+        return;
+      case ProcessorPackage.INVOKE_PIPELET__CONFIGURATION:
+        setConfiguration((Configuration) newValue);
+        return;
     }
+    super.eSet(featureID, newValue);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    private void setVariables(Variables newVariables)
-    {
-        if (newVariables != variables)
-        {
-            NotificationChain msgs = null;
-            if (variables != null)
-            {
-                msgs =
-                        ((InternalEObject) variables).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_PIPELET__VARIABLES, null, msgs);
-            }
-            if (newVariables != null)
-            {
-                msgs =
-                        ((InternalEObject) newVariables).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_PIPELET__VARIABLES, null, msgs);
-            }
-            msgs = basicSetVariables(newVariables, msgs);
-            if (msgs != null)
-            {
-                msgs.dispatch();
-            }
-        }
-        else if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__VARIABLES, newVariables,
-                    newVariables));
-        }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+      case ProcessorPackage.INVOKE_PIPELET__PIPELET:
+        setPipelet((Pipelet) null);
+        return;
+      case ProcessorPackage.INVOKE_PIPELET__VARIABLES:
+        setVariables((Variables) null);
+        return;
+      case ProcessorPackage.INVOKE_PIPELET__CONFIGURATION:
+        setConfiguration((Configuration) null);
+        return;
     }
+    super.eUnset(featureID);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public PipeletConfiguration getPipeletConfiguration()
-    {
-        return pipeletConfiguration;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+      case ProcessorPackage.INVOKE_PIPELET__PIPELET:
+        return pipelet != null;
+      case ProcessorPackage.INVOKE_PIPELET__VARIABLES:
+        return variables != null;
+      case ProcessorPackage.INVOKE_PIPELET__CONFIGURATION:
+        return configuration != null;
     }
+    return super.eIsSet(featureID);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public NotificationChain basicSetPipeletConfiguration(PipeletConfiguration newPipeletConfiguration, NotificationChain msgs)
-    {
-        PipeletConfiguration oldPipeletConfiguration = pipeletConfiguration;
-        pipeletConfiguration = newPipeletConfiguration;
-        if (eNotificationRequired())
-        {
-            ENotificationImpl notification =
-                    new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_PIPELET__PIPELET_CONFIGURATION,
-                            oldPipeletConfiguration, newPipeletConfiguration);
-            if (msgs == null)
-            {
-                msgs = notification;
-            }
-            else
-            {
-                msgs.add(notification);
-            }
-        }
-        return msgs;
+  protected <E extends ExtensionElement> void replaceChild(E oldElement, E newElement) {
+    if (!isReconciling() && !isUpdatingDOM() && getElement() != null && !ReconciliationHelper.isLoading(this)) {
+      if (newElement.fixElement(getElement().getOwnerDocument()) != null) {
+        ReconciliationHelper.replaceChild(this, oldElement, newElement);
+      }
     }
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    private void setPipeletConfiguration(PipeletConfiguration newPipeletConfiguration)
-    {
-        if (newPipeletConfiguration != pipeletConfiguration)
-        {
-            NotificationChain msgs = null;
-            if (pipeletConfiguration != null)
-            {
-                msgs =
-                        ((InternalEObject) pipeletConfiguration).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_PIPELET__PIPELET_CONFIGURATION, null, msgs);
-            }
-            if (newPipeletConfiguration != null)
-            {
-                msgs =
-                        ((InternalEObject) newPipeletConfiguration).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_PIPELET__PIPELET_CONFIGURATION, null, msgs);
-            }
-            msgs = basicSetPipeletConfiguration(newPipeletConfiguration, msgs);
-            if (msgs != null)
-            {
-                msgs.dispatch();
-            }
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.INVOKE_PIPELET__PIPELET :
-                return basicSetPipelet(null, msgs);
-            case ProcessorPackage.INVOKE_PIPELET__VARIABLES :
-                return basicSetVariables(null, msgs);
-            case ProcessorPackage.INVOKE_PIPELET__PIPELET_CONFIGURATION :
-                return basicSetPipeletConfiguration(null, msgs);
-        }
-        return super.eInverseRemove(otherEnd, featureID, msgs);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.INVOKE_PIPELET__PIPELET :
-                return getPipelet();
-            case ProcessorPackage.INVOKE_PIPELET__VARIABLES :
-                return getVariables();
-            case ProcessorPackage.INVOKE_PIPELET__PIPELET_CONFIGURATION :
-                return getPipeletConfiguration();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.INVOKE_PIPELET__PIPELET :
-                return pipelet != null;
-            case ProcessorPackage.INVOKE_PIPELET__VARIABLES :
-                return variables != null;
-            case ProcessorPackage.INVOKE_PIPELET__PIPELET_CONFIGURATION :
-                return pipeletConfiguration != null;
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * Adds HTML elements to all properties.
-     * 
-     * If a XML file contains no elements for the properties, any modification
-     * of these properties wouldn't be reflected in the XML file.
-     * 
-     * Called when one of the properties changes itself.
-     * 
-     * @return true if this element has an element, false else
-     */
-    public boolean fixContent()
-    {
-        if (isReconciling || ReconciliationHelper.isLoading(this) || getElement() == null)
-        {
-            return false;
-        }
-        boolean oldUpdatingDOM = isUpdatingDOM();
-        try
-        {
-            setUpdatingDOM(true);
-
-            List<Element> childElements =
-                    DOMUtils.getChildElements(getElement(), ProcessorPackage.eNS_URI, ProcessorConstants.NODE_INVOKE_PIPELET);
-            Element parentElement;
-            if (childElements.size() == 0)
-            {
-                parentElement =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_INVOKE_PIPELET);
-                parentElement.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.appendIndented(getElement(), parentElement);
-            }
-            else
-            {
-                parentElement = childElements.get(0);
-            }
-
-            if (getPipelet().getElement() == null)
-            {
-                Element element =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_PIPELET);
-                element.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.insertIndented(parentElement, element, DOMUtils.getNextElement(getElement().getFirstChild()));
-                getPipelet().setElement(element);
-            }
-            if (getVariables().getElement() == null)
-            {
-                Element element =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_VARIABLES);
-                element.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.insertIndented(parentElement, element,
-                        DOMUtils.getNextElement(getPipelet().getElement().getNextSibling()));
-                getVariables().setElement(element);
-            }
-            if (getPipeletConfiguration().getElement() == null)
-            {
-                Element element =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_PIPELET_CONFIGURATION);
-                element.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.appendIndented(parentElement, element);
-                getPipeletConfiguration().setElement(element);
-            }
-            return true;
-        }
-        finally
-        {
-            setUpdatingDOM(oldUpdatingDOM);
-        }
-    }
-
-} //InvokePipeletImpl
+} // InvokePipeletImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokeServiceImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokeServiceImpl.java
deleted file mode 100644
index bce0644..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/InvokeServiceImpl.java
+++ /dev/null
@@ -1,458 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.impl;
-
-import java.util.List;
-
-import org.eclipse.bpel.model.impl.ExtensionActivityImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.InternalEObject;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.smila.processing.designer.model.processor.*;
-import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
-import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
-import org.w3c.dom.Element;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Invoke Service</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl#getService <em>Service</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl#getVariables <em>Variables</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.InvokeServiceImpl#getSetAnnotations <em>Set Annotations</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class InvokeServiceImpl extends ExtensionActivityImpl implements InvokeService
-{
-    /**
-     * The cached value of the '{@link #getService() <em>Service</em>}' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getService()
-     * @generated
-     * @ordered
-     */
-    protected Service service;
-
-    /**
-     * The cached value of the '{@link #getVariables() <em>Variables</em>}' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getVariables()
-     * @generated
-     * @ordered
-     */
-    protected Variables variables;
-
-    /**
-     * The cached value of the '{@link #getSetAnnotations() <em>Set Annotations</em>}' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getSetAnnotations()
-     * @generated
-     * @ordered
-     */
-    protected SetAnnotations setAnnotations;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    protected InvokeServiceImpl()
-    {
-        setService(ProcessorFactory.eINSTANCE.createService());
-        setVariables(ProcessorFactory.eINSTANCE.createVariables());
-        setSetAnnotations(ProcessorFactory.eINSTANCE.createSetAnnotations());
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.INVOKE_SERVICE;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Service getService()
-    {
-        return service;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    public NotificationChain basicSetService(Service newService, NotificationChain msgs)
-    {
-        Service oldService = service;
-        service = newService;
-
-        if (!isReconciling)
-        {
-            ReconciliationHelper.replaceChild(this, oldService, newService);
-        }
-
-        if (eNotificationRequired())
-        {
-            ENotificationImpl notification =
-                    new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_SERVICE__SERVICE, oldService,
-                            newService);
-            if (msgs == null)
-            {
-                msgs = notification;
-            }
-            else
-            {
-                msgs.add(notification);
-            }
-        }
-        return msgs;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    public void setService(Service newService)
-    {
-        if (newService != service)
-        {
-            NotificationChain msgs = null;
-            if (service != null)
-            {
-                msgs =
-                        ((InternalEObject) service).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_SERVICE__SERVICE, null, msgs);
-            }
-            if (newService != null)
-            {
-                msgs =
-                        ((InternalEObject) newService).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_SERVICE__SERVICE, null, msgs);
-            }
-            msgs = basicSetService(newService, msgs);
-            if (msgs != null)
-            {
-                msgs.dispatch();
-            }
-        }
-        else if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_SERVICE__SERVICE, newService,
-                    newService));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Variables getVariables()
-    {
-        return variables;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    public NotificationChain basicSetVariables(Variables newVariables, NotificationChain msgs)
-    {
-        Variables oldVariables = variables;
-        variables = newVariables;
-
-        if (!isReconciling)
-        {
-            ReconciliationHelper.replaceChild(this, oldVariables, newVariables);
-        }
-
-        if (eNotificationRequired())
-        {
-            ENotificationImpl notification =
-                    new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_SERVICE__VARIABLES, oldVariables,
-                            newVariables);
-            if (msgs == null)
-            {
-                msgs = notification;
-            }
-            else
-            {
-                msgs.add(notification);
-            }
-        }
-        return msgs;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    public void setVariables(Variables newVariables)
-    {
-        if (newVariables != variables)
-        {
-            NotificationChain msgs = null;
-            if (variables != null)
-            {
-                msgs =
-                        ((InternalEObject) variables).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_SERVICE__VARIABLES, null, msgs);
-            }
-            if (newVariables != null)
-            {
-                msgs =
-                        ((InternalEObject) newVariables).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_SERVICE__VARIABLES, null, msgs);
-            }
-            msgs = basicSetVariables(newVariables, msgs);
-            if (msgs != null)
-            {
-                msgs.dispatch();
-            }
-        }
-        else if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_SERVICE__VARIABLES, newVariables,
-                    newVariables));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public SetAnnotations getSetAnnotations()
-    {
-        return setAnnotations;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    public NotificationChain basicSetSetAnnotations(SetAnnotations newSetAnnotations, NotificationChain msgs)
-    {
-        SetAnnotations oldSetAnnotations = setAnnotations;
-        setAnnotations = newSetAnnotations;
-
-        if (!isReconciling)
-        {
-            ReconciliationHelper.replaceChild(this, oldSetAnnotations, newSetAnnotations);
-        }
-
-        if (eNotificationRequired())
-        {
-            ENotificationImpl notification =
-                    new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS,
-                            oldSetAnnotations, newSetAnnotations);
-            if (msgs == null)
-            {
-                msgs = notification;
-            }
-            else
-            {
-                msgs.add(notification);
-            }
-        }
-        return msgs;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @customized
-     */
-    public void setSetAnnotations(SetAnnotations newSetAnnotations)
-    {
-        if (newSetAnnotations != setAnnotations)
-        {
-            NotificationChain msgs = null;
-            if (setAnnotations != null)
-            {
-                msgs =
-                        ((InternalEObject) setAnnotations).eInverseRemove(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS, null, msgs);
-            }
-            if (newSetAnnotations != null)
-            {
-                msgs =
-                        ((InternalEObject) newSetAnnotations).eInverseAdd(this, EOPPOSITE_FEATURE_BASE
-                                - ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS, null, msgs);
-            }
-            msgs = basicSetSetAnnotations(newSetAnnotations, msgs);
-            if (msgs != null)
-            {
-                msgs.dispatch();
-            }
-        }
-        else if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS,
-                    newSetAnnotations, newSetAnnotations));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.INVOKE_SERVICE__SERVICE :
-                return basicSetService(null, msgs);
-            case ProcessorPackage.INVOKE_SERVICE__VARIABLES :
-                return basicSetVariables(null, msgs);
-            case ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS :
-                return basicSetSetAnnotations(null, msgs);
-        }
-        return super.eInverseRemove(otherEnd, featureID, msgs);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.INVOKE_SERVICE__SERVICE :
-                return getService();
-            case ProcessorPackage.INVOKE_SERVICE__VARIABLES :
-                return getVariables();
-            case ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS :
-                return getSetAnnotations();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.INVOKE_SERVICE__SERVICE :
-                return service != null;
-            case ProcessorPackage.INVOKE_SERVICE__VARIABLES :
-                return variables != null;
-            case ProcessorPackage.INVOKE_SERVICE__SET_ANNOTATIONS :
-                return setAnnotations != null;
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * Adds HTML elements to all properties.
-     * 
-     * If a XML file contains no elements for the properties, any modification
-     * of these properties wouldn't be reflected in the XML file.
-     * 
-     * Called when one of the properties changes itself.
-     * 
-     * @return true if this element has an element, false else
-     */
-    public boolean fixContent()
-    {
-        if (isReconciling || ReconciliationHelper.isLoading(this) || getElement() == null)
-        {
-            return false;
-        }
-        boolean oldUpdatingDOM = isUpdatingDOM();
-        try
-        {
-            setUpdatingDOM(true);
-            List<Element> childElements =
-                    DOMUtils.getChildElements(getElement(), ProcessorPackage.eNS_URI, ProcessorConstants.NODE_INVOKE_SERVICE);
-            Element parentElement;
-            if (childElements.size() == 0)
-            {
-                parentElement =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_INVOKE_SERVICE);
-                parentElement.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.appendIndented(getElement(), parentElement);
-            }
-            else
-            {
-                parentElement = childElements.get(0);
-            }
-
-            if (getService().getElement() == null)
-            {
-                Element element =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_SERVICE);
-                element.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.insertIndented(parentElement, element, DOMUtils.getNextElement(getElement().getFirstChild()));
-                getService().setElement(element);
-            }
-            if (getVariables().getElement() == null)
-            {
-                Element element =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_VARIABLES);
-                element.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.insertIndented(parentElement, element,
-                        DOMUtils.getNextElement(getService().getElement().getNextSibling()));
-                getVariables().setElement(element);
-            }
-            if (getSetAnnotations().getElement() == null)
-            {
-                Element element =
-                        getElement().getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                ProcessorConstants.NODE_SET_ANNOTATIONS);
-                element.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.appendIndented(parentElement, element);
-                getSetAnnotations().setElement(element);
-            }
-            return true;
-        }
-        finally
-        {
-            setUpdatingDOM(oldUpdatingDOM);
-        }
-    }
-} //InvokeServiceImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletConfigurationImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletConfigurationImpl.java
deleted file mode 100644
index 8aa67ce..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletConfigurationImpl.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.impl;
-
-import java.util.Collection;
-import java.util.List;
-
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.smila.processing.designer.model.processor.*;
-import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
-import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
-import org.w3c.dom.Element;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pipelet Configuration</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletConfigurationImpl#getProperties <em>Properties</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PipeletConfigurationImpl extends ExtensibleElementImpl implements PipeletConfiguration
-{
-
-    /**
-     * The cached value of the '{@link #getProperties() <em>Properties</em>}' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getProperties()
-     * @generated
-     * @ordered
-     */
-    protected EList<Property> properties;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected PipeletConfigurationImpl()
-    {
-        super();
-    }
-
-    @Override
-    protected void adoptContent(EReference reference, Object object)
-    {
-        if (!ReconciliationHelper.isLoading(this) && object instanceof Property)
-        {
-            // Modified ReconciliationHelper.adoptChild for our use case
-            Property property = (Property) object;
-            boolean oldUpdatingDom = isUpdatingDOM();
-            try
-            {
-                setUpdatingDOM(true);
-
-                if (getContainer() instanceof InvokePipeletImpl && ((InvokePipeletImpl) getContainer()).fixContent())
-                {
-                    Element parentElement = getElement();
-                    Element propertyElement = property.getElement();
-                    if (propertyElement == null)
-                    {
-                        propertyElement =
-                                parentElement.getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI,
-                                        ProcessorConstants.NODE_PROPERTY);
-                        property.setElement(propertyElement);
-                        propertyElement.setPrefix(ProcessorPackage.eNS_PREFIX);
-                        if (property.getName() != null)
-                        {
-                            propertyElement.setAttribute(ProcessorConstants.ATT_NAME, property.getName());
-                        }
-                    }
-                    if (propertyElement.getParentNode() != parentElement)
-                    {
-                        int index = properties.indexOf(property);
-                        List<Element> elements =
-                                DOMUtils.getChildElements(parentElement, ProcessorPackage.eNS_URI,
-                                        ProcessorConstants.NODE_PROPERTY);
-                        DOMUtils.insertIndented(parentElement, propertyElement,
-                                index >= elements.size() ? null : elements.get(index));
-                    }
-                }
-            }
-            finally
-            {
-                setUpdatingDOM(oldUpdatingDom);
-            }
-        }
-        super.adoptContent(reference, object);
-    }
-
-    @Override
-    protected void orphanContent(EReference reference, Object obj)
-    {
-        if (obj instanceof Property && !isReconciling())
-        {
-            ReconciliationHelper.orphanChild(this, (Property) obj);
-        }
-        super.orphanContent(reference, obj);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.PIPELET_CONFIGURATION;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EList<Property> getProperties()
-    {
-        if (properties == null)
-        {
-            properties =
-                    new EObjectContainmentEList<Property>(Property.class, this,
-                            ProcessorPackage.PIPELET_CONFIGURATION__PROPERTIES);
-        }
-        return properties;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET_CONFIGURATION__PROPERTIES :
-                return ((InternalEList<?>) getProperties()).basicRemove(otherEnd, msgs);
-        }
-        return super.eInverseRemove(otherEnd, featureID, msgs);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET_CONFIGURATION__PROPERTIES :
-                return getProperties();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @SuppressWarnings("unchecked")
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET_CONFIGURATION__PROPERTIES :
-                getProperties().clear();
-                getProperties().addAll((Collection<? extends Property>) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET_CONFIGURATION__PROPERTIES :
-                getProperties().clear();
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET_CONFIGURATION__PROPERTIES :
-                return properties != null && !properties.isEmpty();
-        }
-        return super.eIsSet(featureID);
-    }
-
-} //PipeletConfigurationImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletImpl.java
index 9313fb0..98a9c46 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PipeletImpl.java
@@ -1,12 +1,10 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.impl;
 
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
 import org.eclipse.bpel.model.util.ReconciliationHelper;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
@@ -14,178 +12,177 @@
 import org.eclipse.smila.processing.designer.model.processor.Pipelet;
 import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
 import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
+import org.eclipse.smila.processing.designer.model.record.impl.ExtensionElementImpl;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Pipelet</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Pipelet</b></em>'. <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
  * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl#getClass_ <em>Class</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.PipeletImpl#getClass_ <em>Class</em>}</li>
  * </ul>
  * </p>
- *
+ * 
  * @generated
  */
-public class PipeletImpl extends ExtensibleElementImpl implements Pipelet
-{
-    /**
-     * The default value of the '{@link #getClass_() <em>Class</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getClass_()
-     * @generated
-     * @ordered
-     */
-    protected static final String CLASS_EDEFAULT = null;
+public class PipeletImpl extends ExtensionElementImpl implements Pipelet {
+  /**
+   * The default value of the '{@link #getClass_() <em>Class</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getClass_()
+   * @generated
+   * @ordered
+   */
+  protected static final String CLASS_EDEFAULT = null;
 
-    /**
-     * The cached value of the '{@link #getClass_() <em>Class</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getClass_()
-     * @generated
-     * @ordered
-     */
-    protected String class_ = CLASS_EDEFAULT;
+  /**
+   * The cached value of the '{@link #getClass_() <em>Class</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getClass_()
+   * @generated
+   * @ordered
+   */
+  protected String class_ = CLASS_EDEFAULT;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected PipeletImpl()
-    {
-        super();
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected PipeletImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return ProcessorPackage.Literals.PIPELET;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String getClass_() {
+    return class_;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public void setClass(String newClass) {
+    String oldClass = class_;
+    if (oldClass != newClass && (oldClass == null || !oldClass.equals(newClass))) {
+      class_ = newClass;
+      if (shouldReconcile()) {
+        ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_CLASS, newClass);
+      }
+      if (eNotificationRequired()) {
+        eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.PIPELET__CLASS, oldClass, class_));
+      }
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+      case ProcessorPackage.PIPELET__CLASS:
+        return getClass_();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue) {
+    switch (featureID) {
+      case ProcessorPackage.PIPELET__CLASS:
+        setClass((String) newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+      case ProcessorPackage.PIPELET__CLASS:
+        setClass(CLASS_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+      case ProcessorPackage.PIPELET__CLASS:
+        return CLASS_EDEFAULT == null ? class_ != null : !CLASS_EDEFAULT.equals(class_);
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String toString() {
+    if (eIsProxy()) {
+      return super.toString();
     }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.PIPELET;
+    StringBuffer result = new StringBuffer(super.toString());
+    result.append(" (class: ");
+    result.append(class_);
+    result.append(')');
+    return result.toString();
+  }
+
+  /**
+   * @see ExtensionElementImpl#createFixedElement(Document)
+   */
+  @Override
+  protected Element createFixedElement(Document document) {
+    Element element = document.createElementNS(ProcessorPackage.eNS_URI, ProcessorConstants.ELEMENT_PIPELET);
+    element.setPrefix(ProcessorPackage.eNS_PREFIX);
+    if (class_ != null) {
+      element.setAttribute(ProcessorConstants.ATT_NAME, class_);
     }
+    return element;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getClass_()
-    {
-        return class_;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setClass(String newClass)
-    {
-        String oldClass = class_;
-        class_ = newClass;
-        if (!isReconciling && !isUpdatingDOM() && getContainer() != null && ((InvokePipeletImpl) getContainer()).fixContent())
-        {
-            ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_CLASS, newClass);
-        }
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.PIPELET__CLASS, oldClass, class_));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET__CLASS :
-                return getClass_();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET__CLASS :
-                setClass((String) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET__CLASS :
-                setClass(CLASS_EDEFAULT);
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PIPELET__CLASS :
-                return CLASS_EDEFAULT == null ? class_ != null : !CLASS_EDEFAULT.equals(class_);
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String toString()
-    {
-        if (eIsProxy())
-        {
-            return super.toString();
-        }
-
-        StringBuffer result = new StringBuffer(super.toString());
-        result.append(" (class: ");
-        result.append(class_);
-        result.append(')');
-        return result.toString();
-    }
-
-} //PipeletImpl
+} // PipeletImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorFactoryImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorFactoryImpl.java
index 6220914..f63420c 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorFactoryImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorFactoryImpl.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.impl;
 
@@ -12,196 +11,122 @@
 import org.eclipse.smila.processing.designer.model.processor.*;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model <b>Factory</b>. <!-- end-user-doc -->
+ * 
  * @generated
  */
-public class ProcessorFactoryImpl extends EFactoryImpl implements ProcessorFactory
-{
-    /**
-     * Creates the default factory implementation.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public static ProcessorFactory init()
-    {
-        try
-        {
-            ProcessorFactory theProcessorFactory =
-                    (ProcessorFactory) EPackage.Registry.INSTANCE.getEFactory("http://www.eclipse.org/smila/processor");
-            if (theProcessorFactory != null)
-            {
-                return theProcessorFactory;
-            }
-        }
-        catch (Exception exception)
-        {
-            EcorePlugin.INSTANCE.log(exception);
-        }
-        return new ProcessorFactoryImpl();
+public class ProcessorFactoryImpl extends EFactoryImpl implements ProcessorFactory {
+  /**
+   * Creates the default factory implementation. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public static ProcessorFactory init() {
+    try {
+      ProcessorFactory theProcessorFactory =
+        (ProcessorFactory) EPackage.Registry.INSTANCE.getEFactory("http://www.eclipse.org/smila/processor");
+      if (theProcessorFactory != null) {
+        return theProcessorFactory;
+      }
+    } catch (Exception exception) {
+      EcorePlugin.INSTANCE.log(exception);
     }
+    return new ProcessorFactoryImpl();
+  }
 
-    /**
-     * Creates an instance of the factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public ProcessorFactoryImpl()
-    {
-        super();
+  /**
+   * Creates an instance of the factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public ProcessorFactoryImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EObject create(EClass eClass) {
+    switch (eClass.getClassifierID()) {
+      case ProcessorPackage.INVOKE_PIPELET:
+        return createInvokePipelet();
+      case ProcessorPackage.PIPELET:
+        return createPipelet();
+      case ProcessorPackage.VARIABLES:
+        return createVariables();
+      case ProcessorPackage.CONFIGURATION:
+        return createConfiguration();
+      default:
+        throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
     }
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EObject create(EClass eClass)
-    {
-        switch (eClass.getClassifierID())
-        {
-            case ProcessorPackage.INVOKE_PIPELET :
-                return createInvokePipelet();
-            case ProcessorPackage.PIPELET :
-                return createPipelet();
-            case ProcessorPackage.VARIABLES :
-                return createVariables();
-            case ProcessorPackage.PROPERTY :
-                return createProperty();
-            case ProcessorPackage.PIPELET_CONFIGURATION :
-                return createPipeletConfiguration();
-            case ProcessorPackage.INVOKE_SERVICE :
-                return createInvokeService();
-            case ProcessorPackage.SERVICE :
-                return createService();
-            case ProcessorPackage.SET_ANNOTATIONS :
-                return createSetAnnotations();
-            default :
-                throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
-        }
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public InvokePipelet createInvokePipelet() {
+    InvokePipeletImpl invokePipelet = new InvokePipeletImpl();
+    return invokePipelet;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public InvokePipelet createInvokePipelet()
-    {
-        InvokePipeletImpl invokePipelet = new InvokePipeletImpl();
-        return invokePipelet;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Pipelet createPipelet() {
+    PipeletImpl pipelet = new PipeletImpl();
+    return pipelet;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Pipelet createPipelet()
-    {
-        PipeletImpl pipelet = new PipeletImpl();
-        return pipelet;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Variables createVariables() {
+    VariablesImpl variables = new VariablesImpl();
+    return variables;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Variables createVariables()
-    {
-        VariablesImpl variables = new VariablesImpl();
-        return variables;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Configuration createConfiguration() {
+    ConfigurationImpl configuration = new ConfigurationImpl();
+    return configuration;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Property createProperty()
-    {
-        PropertyImpl property = new PropertyImpl();
-        return property;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public ProcessorPackage getProcessorPackage() {
+    return (ProcessorPackage) getEPackage();
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public PipeletConfiguration createPipeletConfiguration()
-    {
-        PipeletConfigurationImpl pipeletConfiguration = new PipeletConfigurationImpl();
-        return pipeletConfiguration;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @deprecated
+   * @generated
+   */
+  @Deprecated
+  public static ProcessorPackage getPackage() {
+    return ProcessorPackage.eINSTANCE;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public InvokeService createInvokeService()
-    {
-        InvokeServiceImpl invokeService = new InvokeServiceImpl();
-        return invokeService;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Service createService()
-    {
-        ServiceImpl service = new ServiceImpl();
-        return service;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public SetAnnotations createSetAnnotations()
-    {
-        SetAnnotationsImpl setAnnotations = new SetAnnotationsImpl();
-        return setAnnotations;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public ProcessorPackage getProcessorPackage()
-    {
-        return (ProcessorPackage) getEPackage();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @deprecated
-     * @generated
-     */
-    @Deprecated
-    public static ProcessorPackage getPackage()
-    {
-        return ProcessorPackage.eINSTANCE;
-    }
-
-} //ProcessorFactoryImpl
+} // ProcessorFactoryImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorPackageImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorPackageImpl.java
index ddb9299..354a9dd 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorPackageImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ProcessorPackageImpl.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.impl;
 
@@ -17,575 +16,334 @@
 import org.eclipse.smila.processing.designer.model.record.RecordPackage;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model <b>Package</b>. <!-- end-user-doc -->
+ * 
  * @generated
  */
-public class ProcessorPackageImpl extends EPackageImpl implements ProcessorPackage
-{
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass invokePipeletEClass = null;
+public class ProcessorPackageImpl extends EPackageImpl implements ProcessorPackage {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass invokePipeletEClass = null;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass pipeletEClass = null;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass pipeletEClass = null;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass variablesEClass = null;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass variablesEClass = null;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass propertyEClass = null;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass configurationEClass = null;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass pipeletConfigurationEClass = null;
+  /**
+   * Creates an instance of the model <b>Package</b>, registered with {@link org.eclipse.emf.ecore.EPackage.Registry
+   * EPackage.Registry} by the package package URI value.
+   * <p>
+   * Note: the correct way to create the package is via the static factory method {@link #init init()}, which also
+   * performs initialization of the package, or returns the registered package, if one already exists. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.emf.ecore.EPackage.Registry
+   * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#eNS_URI
+   * @see #init()
+   * @generated
+   */
+  private ProcessorPackageImpl() {
+    super(eNS_URI, ProcessorFactory.eINSTANCE);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass invokeServiceEClass = null;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private static boolean isInited = false;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass serviceEClass = null;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass setAnnotationsEClass = null;
-
-    /**
-     * Creates an instance of the model <b>Package</b>, registered with
-     * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-     * package URI value.
-     * <p>Note: the correct way to create the package is via the static
-     * factory method {@link #init init()}, which also performs
-     * initialization of the package, or returns the registered package,
-     * if one already exists.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.emf.ecore.EPackage.Registry
-     * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage#eNS_URI
-     * @see #init()
-     * @generated
-     */
-    private ProcessorPackageImpl()
-    {
-        super(eNS_URI, ProcessorFactory.eINSTANCE);
+  /**
+   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+   * 
+   * <p>
+   * This method is used to initialize {@link ProcessorPackage#eINSTANCE} when that field is accessed. Clients should
+   * not invoke it directly. Instead, they should simply access that field to obtain the package. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @see #eNS_URI
+   * @see #createPackageContents()
+   * @see #initializePackageContents()
+   * @customized
+   */
+  public static ProcessorPackage init() {
+    if (isInited) {
+      return (ProcessorPackage) EPackage.Registry.INSTANCE.getEPackage(ProcessorPackage.eNS_URI);
     }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private static boolean isInited = false;
+    // Obtain or create and register package
+    ProcessorPackageImpl theProcessorPackage =
+      (ProcessorPackageImpl) (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ProcessorPackageImpl ? EPackage.Registry.INSTANCE
+        .get(eNS_URI) : new ProcessorPackageImpl());
 
-    /**
-     * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
-     * 
-     * <p>This method is used to initialize {@link ProcessorPackage#eINSTANCE} when that field is accessed.
-     * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #eNS_URI
-     * @see #createPackageContents()
-     * @see #initializePackageContents()
-     * @customized
-     */
-    public static ProcessorPackage init()
-    {
-        if (isInited)
-        {
-            return (ProcessorPackage) EPackage.Registry.INSTANCE.getEPackage(ProcessorPackage.eNS_URI);
-        }
+    isInited = true;
 
-        // Obtain or create and register package
-        ProcessorPackageImpl theProcessorPackage =
-                (ProcessorPackageImpl) (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ProcessorPackageImpl
-                        ? EPackage.Registry.INSTANCE.get(eNS_URI) : new ProcessorPackageImpl());
+    // Initialize simple dependencies
+    RecordPackage.eINSTANCE.eClass();
 
-        isInited = true;
+    // Create package meta-data objects
+    theProcessorPackage.createPackageContents();
 
-        // Initialize simple dependencies
-        RecordPackage.eINSTANCE.eClass();
+    // Initialize created meta-data
+    theProcessorPackage.initializePackageContents();
 
-        // Create package meta-data objects
-        theProcessorPackage.createPackageContents();
+    // Mark meta-data to indicate it can't be changed
+    theProcessorPackage.freeze();
 
-        // Initialize created meta-data
-        theProcessorPackage.initializePackageContents();
+    // Update the registry and return the package
+    EPackage.Registry.INSTANCE.put(ProcessorPackage.eNS_URI, theProcessorPackage);
 
-        // Mark meta-data to indicate it can't be changed
-        theProcessorPackage.freeze();
+    // Register serializer/deserializer
+    registerSerializerAndDeserializer();
 
-        // Update the registry and return the package
-        EPackage.Registry.INSTANCE.put(ProcessorPackage.eNS_URI, theProcessorPackage);
+    return theProcessorPackage;
+  }
 
-        // Register serializer/deserializer
-        registerSerializerAndDeserializer();
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getInvokePipelet() {
+    return invokePipeletEClass;
+  }
 
-        return theProcessorPackage;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EReference getInvokePipelet_Pipelet() {
+    return (EReference) invokePipeletEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EReference getInvokePipelet_Variables() {
+    return (EReference) invokePipeletEClass.getEStructuralFeatures().get(1);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EReference getInvokePipelet_Configuration() {
+    return (EReference) invokePipeletEClass.getEStructuralFeatures().get(2);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getPipelet() {
+    return pipeletEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EAttribute getPipelet_Class() {
+    return (EAttribute) pipeletEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getVariables() {
+    return variablesEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EAttribute getVariables_Input() {
+    return (EAttribute) variablesEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EAttribute getVariables_Output() {
+    return (EAttribute) variablesEClass.getEStructuralFeatures().get(1);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getConfiguration() {
+    return configurationEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public ProcessorFactory getProcessorFactory() {
+    return (ProcessorFactory) getEFactoryInstance();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private boolean isCreated = false;
+
+  /**
+   * Creates the meta-model objects for the package. This method is guarded to have no affect on any invocation but its
+   * first. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public void createPackageContents() {
+    if (isCreated) {
+      return;
     }
+    isCreated = true;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getInvokePipelet()
-    {
-        return invokePipeletEClass;
+    // Create classes and their features
+    invokePipeletEClass = createEClass(INVOKE_PIPELET);
+    createEReference(invokePipeletEClass, INVOKE_PIPELET__PIPELET);
+    createEReference(invokePipeletEClass, INVOKE_PIPELET__VARIABLES);
+    createEReference(invokePipeletEClass, INVOKE_PIPELET__CONFIGURATION);
+
+    pipeletEClass = createEClass(PIPELET);
+    createEAttribute(pipeletEClass, PIPELET__CLASS);
+
+    variablesEClass = createEClass(VARIABLES);
+    createEAttribute(variablesEClass, VARIABLES__INPUT);
+    createEAttribute(variablesEClass, VARIABLES__OUTPUT);
+
+    configurationEClass = createEClass(CONFIGURATION);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private boolean isInitialized = false;
+
+  /**
+   * Complete the initialization of the package and its meta-model. This method is guarded to have no affect on any
+   * invocation but its first. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public void initializePackageContents() {
+    if (isInitialized) {
+      return;
     }
+    isInitialized = true;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getInvokePipelet_Pipelet()
-    {
-        return (EReference) invokePipeletEClass.getEStructuralFeatures().get(0);
-    }
+    // Initialize package
+    setName(eNAME);
+    setNsPrefix(eNS_PREFIX);
+    setNsURI(eNS_URI);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getInvokePipelet_Variables()
-    {
-        return (EReference) invokePipeletEClass.getEStructuralFeatures().get(1);
-    }
+    // Obtain other dependent packages
+    BPELPackage theBPELPackage = (BPELPackage) EPackage.Registry.INSTANCE.getEPackage(BPELPackage.eNS_URI);
+    RecordPackage theRecordPackage = (RecordPackage) EPackage.Registry.INSTANCE.getEPackage(RecordPackage.eNS_URI);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getInvokePipelet_PipeletConfiguration()
-    {
-        return (EReference) invokePipeletEClass.getEStructuralFeatures().get(2);
-    }
+    // Create type parameters
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getPipelet()
-    {
-        return pipeletEClass;
-    }
+    // Set bounds for type parameters
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getPipelet_Class()
-    {
-        return (EAttribute) pipeletEClass.getEStructuralFeatures().get(0);
-    }
+    // Add supertypes to classes
+    invokePipeletEClass.getESuperTypes().add(theBPELPackage.getExtensionActivity());
+    invokePipeletEClass.getESuperTypes().add(theRecordPackage.getExtensionElement());
+    pipeletEClass.getESuperTypes().add(theRecordPackage.getExtensionElement());
+    variablesEClass.getESuperTypes().add(theRecordPackage.getExtensionElement());
+    configurationEClass.getESuperTypes().add(theRecordPackage.getRecordMap());
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getVariables()
-    {
-        return variablesEClass;
-    }
+    // Initialize classes and features; add operations and parameters
+    initEClass(invokePipeletEClass, InvokePipelet.class, "InvokePipelet", !IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getInvokePipelet_Pipelet(), this.getPipelet(), null, "pipelet", null, 1, 1, InvokePipelet.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
+      !IS_DERIVED, IS_ORDERED);
+    initEReference(getInvokePipelet_Variables(), this.getVariables(), null, "variables", null, 1, 1,
+      InvokePipelet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
+      !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getInvokePipelet_Configuration(), this.getConfiguration(), null, "configuration", null, 1, 1,
+      InvokePipelet.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
+      !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getVariables_Input()
-    {
-        return (EAttribute) variablesEClass.getEStructuralFeatures().get(0);
-    }
+    initEClass(pipeletEClass, Pipelet.class, "Pipelet", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getPipelet_Class(), ecorePackage.getEString(), "class", null, 1, 1, Pipelet.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getVariables_Output()
-    {
-        return (EAttribute) variablesEClass.getEStructuralFeatures().get(1);
-    }
+    initEClass(variablesEClass, Variables.class, "Variables", !IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getVariables_Input(), ecorePackage.getEString(), "input", null, 1, 1, Variables.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEAttribute(getVariables_Output(), ecorePackage.getEString(), "output", null, 1, 1, Variables.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getProperty()
-    {
-        return propertyEClass;
-    }
+    initEClass(configurationEClass, Configuration.class, "Configuration", !IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getProperty_Name()
-    {
-        return (EAttribute) propertyEClass.getEStructuralFeatures().get(0);
-    }
+    // Create resource
+    createResource(eNS_URI);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getProperty_Value()
-    {
-        return (EAttribute) propertyEClass.getEStructuralFeatures().get(1);
-    }
+  private static void registerSerializerAndDeserializer() {
+    BPELExtensionRegistry extensionRegistry = BPELExtensionRegistry.getInstance();
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getPipeletConfiguration()
-    {
-        return pipeletConfigurationEClass;
-    }
+    InvokePipeletDeserializer invokePipeletDeserializer = new InvokePipeletDeserializer();
+    InvokePipeletSerializer invokePipeletSerializer = new InvokePipeletSerializer();
+    String invokePipeletName = InvokePipelet.class.getSimpleName();
+    extensionRegistry.registerActivityDeserializer(new QName(ProcessorPackage.eNS_URI,
+      ProcessorConstants.ELEMENT_INVOKE_PIPELET), invokePipeletDeserializer);
+    extensionRegistry.registerActivitySerializer(new QName(ProcessorPackage.eNS_URI, invokePipeletName),
+      invokePipeletSerializer);
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getPipeletConfiguration_Properties()
-    {
-        return (EReference) pipeletConfigurationEClass.getEStructuralFeatures().get(0);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getInvokeService()
-    {
-        return invokeServiceEClass;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getInvokeService_Service()
-    {
-        return (EReference) invokeServiceEClass.getEStructuralFeatures().get(0);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getInvokeService_Variables()
-    {
-        return (EReference) invokeServiceEClass.getEStructuralFeatures().get(1);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getInvokeService_SetAnnotations()
-    {
-        return (EReference) invokeServiceEClass.getEStructuralFeatures().get(2);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getService()
-    {
-        return serviceEClass;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getService_Name()
-    {
-        return (EAttribute) serviceEClass.getEStructuralFeatures().get(0);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getSetAnnotations()
-    {
-        return setAnnotationsEClass;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getSetAnnotations_Annotations()
-    {
-        return (EReference) setAnnotationsEClass.getEStructuralFeatures().get(0);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public ProcessorFactory getProcessorFactory()
-    {
-        return (ProcessorFactory) getEFactoryInstance();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private boolean isCreated = false;
-
-    /**
-     * Creates the meta-model objects for the package.  This method is
-     * guarded to have no affect on any invocation but its first.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public void createPackageContents()
-    {
-        if (isCreated)
-        {
-            return;
-        }
-        isCreated = true;
-
-        // Create classes and their features
-        invokePipeletEClass = createEClass(INVOKE_PIPELET);
-        createEReference(invokePipeletEClass, INVOKE_PIPELET__PIPELET);
-        createEReference(invokePipeletEClass, INVOKE_PIPELET__VARIABLES);
-        createEReference(invokePipeletEClass, INVOKE_PIPELET__PIPELET_CONFIGURATION);
-
-        pipeletEClass = createEClass(PIPELET);
-        createEAttribute(pipeletEClass, PIPELET__CLASS);
-
-        variablesEClass = createEClass(VARIABLES);
-        createEAttribute(variablesEClass, VARIABLES__INPUT);
-        createEAttribute(variablesEClass, VARIABLES__OUTPUT);
-
-        propertyEClass = createEClass(PROPERTY);
-        createEAttribute(propertyEClass, PROPERTY__NAME);
-        createEAttribute(propertyEClass, PROPERTY__VALUE);
-
-        pipeletConfigurationEClass = createEClass(PIPELET_CONFIGURATION);
-        createEReference(pipeletConfigurationEClass, PIPELET_CONFIGURATION__PROPERTIES);
-
-        invokeServiceEClass = createEClass(INVOKE_SERVICE);
-        createEReference(invokeServiceEClass, INVOKE_SERVICE__SERVICE);
-        createEReference(invokeServiceEClass, INVOKE_SERVICE__VARIABLES);
-        createEReference(invokeServiceEClass, INVOKE_SERVICE__SET_ANNOTATIONS);
-
-        serviceEClass = createEClass(SERVICE);
-        createEAttribute(serviceEClass, SERVICE__NAME);
-
-        setAnnotationsEClass = createEClass(SET_ANNOTATIONS);
-        createEReference(setAnnotationsEClass, SET_ANNOTATIONS__ANNOTATIONS);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private boolean isInitialized = false;
-
-    /**
-     * Complete the initialization of the package and its meta-model.  This
-     * method is guarded to have no affect on any invocation but its first.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public void initializePackageContents()
-    {
-        if (isInitialized)
-        {
-            return;
-        }
-        isInitialized = true;
-
-        // Initialize package
-        setName(eNAME);
-        setNsPrefix(eNS_PREFIX);
-        setNsURI(eNS_URI);
-
-        // Obtain other dependent packages
-        BPELPackage theBPELPackage = (BPELPackage) EPackage.Registry.INSTANCE.getEPackage(BPELPackage.eNS_URI);
-        RecordPackage theRecordPackage = (RecordPackage) EPackage.Registry.INSTANCE.getEPackage(RecordPackage.eNS_URI);
-
-        // Create type parameters
-
-        // Set bounds for type parameters
-
-        // Add supertypes to classes
-        invokePipeletEClass.getESuperTypes().add(theBPELPackage.getExtensionActivity());
-        pipeletEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-        variablesEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-        propertyEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-        pipeletConfigurationEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-        invokeServiceEClass.getESuperTypes().add(theBPELPackage.getExtensionActivity());
-        serviceEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-        setAnnotationsEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-
-        // Initialize classes and features; add operations and parameters
-        initEClass(invokePipeletEClass, InvokePipelet.class, "InvokePipelet", !IS_ABSTRACT, !IS_INTERFACE,
-                IS_GENERATED_INSTANCE_CLASS);
-        initEReference(getInvokePipelet_Pipelet(), this.getPipelet(), null, "pipelet", null, 1, 1, InvokePipelet.class,
-                !IS_TRANSIENT, !IS_VOLATILE, !IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-                !IS_DERIVED, !IS_ORDERED);
-        initEReference(getInvokePipelet_Variables(), this.getVariables(), null, "variables", null, 1, 1, InvokePipelet.class,
-                !IS_TRANSIENT, !IS_VOLATILE, !IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-                !IS_DERIVED, !IS_ORDERED);
-        initEReference(getInvokePipelet_PipeletConfiguration(), this.getPipeletConfiguration(), null, "pipeletConfiguration",
-                null, 1, 1, InvokePipelet.class, !IS_TRANSIENT, !IS_VOLATILE, !IS_CHANGEABLE, IS_COMPOSITE,
-                !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
-
-        initEClass(pipeletEClass, Pipelet.class, "Pipelet", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-        initEAttribute(getPipelet_Class(), ecorePackage.getEString(), "class", null, 1, 1, Pipelet.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        initEClass(variablesEClass, Variables.class, "Variables", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-        initEAttribute(getVariables_Input(), ecorePackage.getEString(), "input", null, 1, 1, Variables.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-        initEAttribute(getVariables_Output(), ecorePackage.getEString(), "output", null, 1, 1, Variables.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        initEClass(propertyEClass, Property.class, "Property", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-        initEAttribute(getProperty_Name(), ecorePackage.getEString(), "name", null, 1, 1, Property.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-        initEAttribute(getProperty_Value(), ecorePackage.getEString(), "value", null, 1, 1, Property.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        initEClass(pipeletConfigurationEClass, PipeletConfiguration.class, "PipeletConfiguration", !IS_ABSTRACT, !IS_INTERFACE,
-                IS_GENERATED_INSTANCE_CLASS);
-        initEReference(getPipeletConfiguration_Properties(), this.getProperty(), null, "properties", null, 0, -1,
-                PipeletConfiguration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
-                !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        initEClass(invokeServiceEClass, InvokeService.class, "InvokeService", !IS_ABSTRACT, !IS_INTERFACE,
-                IS_GENERATED_INSTANCE_CLASS);
-        initEReference(getInvokeService_Service(), this.getService(), null, "service", null, 1, 1, InvokeService.class,
-                !IS_TRANSIENT, !IS_VOLATILE, !IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-                !IS_DERIVED, !IS_ORDERED);
-        initEReference(getInvokeService_Variables(), this.getVariables(), null, "variables", null, 1, 1, InvokeService.class,
-                !IS_TRANSIENT, !IS_VOLATILE, !IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-                !IS_DERIVED, !IS_ORDERED);
-        initEReference(getInvokeService_SetAnnotations(), this.getSetAnnotations(), null, "setAnnotations", null, 0, 1,
-                InvokeService.class, !IS_TRANSIENT, !IS_VOLATILE, !IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
-                !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        initEClass(serviceEClass, Service.class, "Service", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-        initEAttribute(getService_Name(), ecorePackage.getEString(), "name", null, 1, 1, Service.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        initEClass(setAnnotationsEClass, SetAnnotations.class, "SetAnnotations", !IS_ABSTRACT, !IS_INTERFACE,
-                IS_GENERATED_INSTANCE_CLASS);
-        initEReference(getSetAnnotations_Annotations(), theRecordPackage.getAnnotation(), null, "Annotations", null, 0, -1,
-                SetAnnotations.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
-                !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        // Create resource
-        createResource(eNS_URI);
-    }
-
-    private static void registerSerializerAndDeserializer()
-    {
-        BPELExtensionRegistry extensionRegistry = BPELExtensionRegistry.getInstance();
-
-        InvokePipeletDeserializer invokePipeletDeserializer = new InvokePipeletDeserializer();
-        InvokePipeletSerializer invokePipeletSerializer = new InvokePipeletSerializer();
-        String invokePipeletName = InvokePipelet.class.getSimpleName();
-        extensionRegistry.registerActivityDeserializer(new QName(ProcessorPackage.eNS_URI,
-                ProcessorConstants.NODE_INVOKE_PIPELET), invokePipeletDeserializer);
-        extensionRegistry.registerActivitySerializer(new QName(ProcessorPackage.eNS_URI, invokePipeletName),
-                invokePipeletSerializer);
-
-        InvokeServiceDeserializer invokeServiceDeserializer = new InvokeServiceDeserializer();
-        InvokeServiceSerializer invokeServiceSerializer = new InvokeServiceSerializer();
-        String invokeServiceName = InvokeService.class.getSimpleName();
-        extensionRegistry.registerActivityDeserializer(new QName(ProcessorPackage.eNS_URI,
-                ProcessorConstants.NODE_INVOKE_SERVICE), invokeServiceDeserializer);
-        extensionRegistry.registerActivitySerializer(new QName(ProcessorPackage.eNS_URI, invokeServiceName),
-                invokeServiceSerializer);
-    }
-
-} //ProcessorPackageImpl
+} // ProcessorPackageImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PropertyImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PropertyImpl.java
deleted file mode 100644
index 4ff3f4d..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/PropertyImpl.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.impl;
-
-import java.util.List;
-
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
-import org.eclipse.smila.processing.designer.model.processor.Property;
-import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
-import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
-import org.w3c.dom.Element;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Property</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.PropertyImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.PropertyImpl#getValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class PropertyImpl extends ExtensibleElementImpl implements Property
-{
-    /**
-     * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected static final String NAME_EDEFAULT = null;
-
-    /**
-     * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected String name = NAME_EDEFAULT;
-
-    /**
-     * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getValue()
-     * @generated
-     * @ordered
-     */
-    protected static final String VALUE_EDEFAULT = null;
-
-    /**
-     * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getValue()
-     * @generated
-     * @ordered
-     */
-    protected String value = VALUE_EDEFAULT;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected PropertyImpl()
-    {
-        super();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.PROPERTY;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getName()
-    {
-        return name;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setName(String newName)
-    {
-        String oldName = name;
-        name = newName;
-        if (!isReconciling)
-        {
-            ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_NAME, newName);
-        }
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.PROPERTY__NAME, oldName, name));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getValue()
-    {
-        return value;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setValue(String newValue)
-    {
-        String oldValue = value;
-        value = newValue;
-        if (!isReconciling)
-        {
-            replaceValue(newValue);
-        }
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.PROPERTY__VALUE, oldValue, value));
-        }
-    }
-
-    /**
-     * Replaces the value at the linked element.
-     * 
-     * Can't use {@link ReconciliationHelper#replaceText} as we have an additional XML node (Value) that contains the text.
-     *
-     * @param newValue the new value
-     */
-    private void replaceValue(String newValue)
-    {
-        if (ReconciliationHelper.isLoading(this))
-        {
-            return;
-        }
-
-        boolean oldUpdatingDom = isUpdatingDOM();
-        try
-        {
-            setUpdatingDOM(true);
-
-            Element element = getElement();
-            if (element == null)
-            {
-                System.err.println("trying to replace text on null element");
-                return;
-            }
-
-            List<Element> elements =
-                    DOMUtils.getChildElements(element, ProcessorPackage.eNS_URI, ProcessorConstants.NODE_VALUE);
-            Element valueElement;
-            if (elements.isEmpty())
-            {
-                valueElement =
-                        element.getOwnerDocument().createElementNS(ProcessorPackage.eNS_URI, ProcessorConstants.NODE_VALUE);
-                valueElement.setPrefix(ProcessorPackage.eNS_PREFIX);
-                DOMUtils.appendIndented(element, valueElement);
-            }
-            else
-            {
-                valueElement = elements.get(0);
-            }
-            DOMUtils.writeTextContent(valueElement, newValue);
-        }
-        finally
-        {
-            setUpdatingDOM(oldUpdatingDom);
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PROPERTY__NAME :
-                return getName();
-            case ProcessorPackage.PROPERTY__VALUE :
-                return getValue();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PROPERTY__NAME :
-                setName((String) newValue);
-                return;
-            case ProcessorPackage.PROPERTY__VALUE :
-                setValue((String) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PROPERTY__NAME :
-                setName(NAME_EDEFAULT);
-                return;
-            case ProcessorPackage.PROPERTY__VALUE :
-                setValue(VALUE_EDEFAULT);
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.PROPERTY__NAME :
-                return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-            case ProcessorPackage.PROPERTY__VALUE :
-                return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String toString()
-    {
-        if (eIsProxy())
-        {
-            return super.toString();
-        }
-
-        StringBuffer result = new StringBuffer(super.toString());
-        result.append(" (name: ");
-        result.append(name);
-        result.append(", value: ");
-        result.append(value);
-        result.append(')');
-        return result.toString();
-    }
-
-} //PropertyImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ServiceImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ServiceImpl.java
deleted file mode 100644
index 86557bb..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/ServiceImpl.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.impl;
-
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
-import org.eclipse.smila.processing.designer.model.processor.Service;
-import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Service</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.ServiceImpl#getName <em>Name</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class ServiceImpl extends ExtensibleElementImpl implements Service
-{
-    /**
-     * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected static final String NAME_EDEFAULT = null;
-
-    /**
-     * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected String name = NAME_EDEFAULT;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected ServiceImpl()
-    {
-        super();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.SERVICE;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getName()
-    {
-        return name;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setName(String newName)
-    {
-        String oldName = name;
-        name = newName;
-
-        if (!isReconciling)
-        {
-            ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_NAME, newName);
-        }
-
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.SERVICE__NAME, oldName, name));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SERVICE__NAME :
-                return getName();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SERVICE__NAME :
-                setName((String) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SERVICE__NAME :
-                setName(NAME_EDEFAULT);
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SERVICE__NAME :
-                return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String toString()
-    {
-        if (eIsProxy())
-        {
-            return super.toString();
-        }
-
-        StringBuffer result = new StringBuffer(super.toString());
-        result.append(" (name: ");
-        result.append(name);
-        result.append(')');
-        return result.toString();
-    }
-
-} //ServiceImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/SetAnnotationsImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/SetAnnotationsImpl.java
deleted file mode 100644
index 16fda35..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/SetAnnotationsImpl.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.impl;
-
-import java.util.Collection;
-
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
-import org.eclipse.smila.processing.designer.model.processor.SetAnnotations;
-import org.eclipse.smila.processing.designer.model.record.Annotation;
-import org.eclipse.smila.processing.designer.model.record.RecordPackage;
-import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
-import org.w3c.dom.Element;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Set Annotations</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.SetAnnotationsImpl#getAnnotations <em>Annotations</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class SetAnnotationsImpl extends ExtensibleElementImpl implements SetAnnotations
-{
-    /**
-     * The cached value of the '{@link #getAnnotations() <em>Annotations</em>}' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getAnnotations()
-     * @generated
-     * @ordered
-     */
-    protected EList<Annotation> annotations;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected SetAnnotationsImpl()
-    {
-        super();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.SET_ANNOTATIONS;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EList<Annotation> getAnnotations()
-    {
-        if (annotations == null)
-        {
-            annotations =
-                    new EObjectContainmentEList<Annotation>(Annotation.class, this,
-                            ProcessorPackage.SET_ANNOTATIONS__ANNOTATIONS);
-        }
-        return annotations;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SET_ANNOTATIONS__ANNOTATIONS :
-                return ((InternalEList<?>) getAnnotations()).basicRemove(otherEnd, msgs);
-        }
-        return super.eInverseRemove(otherEnd, featureID, msgs);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SET_ANNOTATIONS__ANNOTATIONS :
-                return getAnnotations();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @SuppressWarnings("unchecked")
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SET_ANNOTATIONS__ANNOTATIONS :
-                getAnnotations().clear();
-                getAnnotations().addAll((Collection<? extends Annotation>) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SET_ANNOTATIONS__ANNOTATIONS :
-                getAnnotations().clear();
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.SET_ANNOTATIONS__ANNOTATIONS :
-                return annotations != null && !annotations.isEmpty();
-        }
-        return super.eIsSet(featureID);
-    }
-
-    @Override
-    protected void adoptContent(EReference eReference, Object object)
-    {
-        if (!ReconciliationHelper.isLoading(this) && object instanceof Annotation)
-        {
-            Annotation annotation = (Annotation) object;
-            boolean oldUpdatingDom = isUpdatingDOM();
-            try
-            {
-                setUpdatingDOM(true);
-
-                if (getContainer() instanceof InvokeServiceImpl && ((InvokeServiceImpl) getContainer()).fixContent())
-                {
-                    Element parentElement = getElement();
-                    Element annotationElement = annotation.getElement();
-                    if (annotationElement == null)
-                    {
-                        annotationElement =
-                                parentElement.getOwnerDocument()
-                                        .createElementNS(RecordPackage.eNS_URI, RecordConstants.NODE_AN);
-                        annotation.setElement(annotationElement);
-                        annotationElement.setPrefix(RecordPackage.eNS_PREFIX);
-                        if (annotation.getName() != null)
-                        {
-                            annotationElement.setAttribute(RecordConstants.ATT_N, annotation.getName());
-                        }
-                    }
-                }
-            }
-            finally
-            {
-                setUpdatingDOM(oldUpdatingDom);
-            }
-        }
-        super.adoptContent(eReference, object);
-    }
-
-    @Override
-    protected void orphanContent(EReference eReference, Object obj)
-    {
-        if (obj instanceof Annotation && !isReconciling())
-        {
-            ReconciliationHelper.orphanChild(this, (Annotation) obj);
-        }
-        super.orphanContent(eReference, obj);
-    }
-
-} //SetAnnotationsImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/VariablesImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/VariablesImpl.java
index ed053e3..f6fb90d 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/VariablesImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/impl/VariablesImpl.java
@@ -1,12 +1,10 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.impl;
 
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
 import org.eclipse.bpel.model.util.ReconciliationHelper;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EClass;
@@ -14,252 +12,246 @@
 import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
 import org.eclipse.smila.processing.designer.model.processor.Variables;
 import org.eclipse.smila.processing.designer.model.processor.util.ProcessorConstants;
+import org.eclipse.smila.processing.designer.model.record.impl.ExtensionElementImpl;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Variables</b></em>'.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Variables</b></em>'. <!-- end-user-doc -->
  * <p>
  * The following features are implemented:
  * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl#getInput <em>Input</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl#getOutput <em>Output</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl#getInput <em>Input</em>}</li>
+ * <li>{@link org.eclipse.smila.processing.designer.model.processor.impl.VariablesImpl#getOutput <em>Output</em>}</li>
  * </ul>
  * </p>
- *
+ * 
  * @generated
  */
-public class VariablesImpl extends ExtensibleElementImpl implements Variables
-{
-    /**
-     * The default value of the '{@link #getInput() <em>Input</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getInput()
-     * @generated
-     * @ordered
-     */
-    protected static final String INPUT_EDEFAULT = null;
+public class VariablesImpl extends ExtensionElementImpl implements Variables {
+  /**
+   * The default value of the '{@link #getInput() <em>Input</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getInput()
+   * @generated
+   * @ordered
+   */
+  protected static final String INPUT_EDEFAULT = null;
 
-    /**
-     * The cached value of the '{@link #getInput() <em>Input</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getInput()
-     * @generated
-     * @ordered
-     */
-    protected String input = INPUT_EDEFAULT;
+  /**
+   * The cached value of the '{@link #getInput() <em>Input</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getInput()
+   * @generated
+   * @ordered
+   */
+  protected String input = INPUT_EDEFAULT;
 
-    /**
-     * The default value of the '{@link #getOutput() <em>Output</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getOutput()
-     * @generated
-     * @ordered
-     */
-    protected static final String OUTPUT_EDEFAULT = null;
+  /**
+   * The default value of the '{@link #getOutput() <em>Output</em>}' attribute. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @see #getOutput()
+   * @generated
+   * @ordered
+   */
+  protected static final String OUTPUT_EDEFAULT = null;
 
-    /**
-     * The cached value of the '{@link #getOutput() <em>Output</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getOutput()
-     * @generated
-     * @ordered
-     */
-    protected String output = OUTPUT_EDEFAULT;
+  /**
+   * The cached value of the '{@link #getOutput() <em>Output</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getOutput()
+   * @generated
+   * @ordered
+   */
+  protected String output = OUTPUT_EDEFAULT;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected VariablesImpl()
-    {
-        super();
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected VariablesImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return ProcessorPackage.Literals.VARIABLES;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String getInput() {
+    return input;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public void setInput(String newInput) {
+    String oldInput = input;
+    if (oldInput != newInput && (oldInput == null || !oldInput.equals(newInput))) {
+      input = newInput;
+
+      if (shouldReconcile()) {
+        ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_INPUT, newInput);
+      }
+
+      if (eNotificationRequired()) {
+        eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.VARIABLES__INPUT, oldInput, input));
+      }
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String getOutput() {
+    return output;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public void setOutput(String newOutput) {
+    String oldOutput = output;
+    if (oldOutput != newOutput && (oldOutput == null || !oldOutput.equals(newOutput))) {
+      output = newOutput;
+
+      if (shouldReconcile()) {
+        ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_OUTPUT, newOutput);
+      }
+
+      if (eNotificationRequired()) {
+        eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.VARIABLES__OUTPUT, oldOutput, output));
+      }
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+      case ProcessorPackage.VARIABLES__INPUT:
+        return getInput();
+      case ProcessorPackage.VARIABLES__OUTPUT:
+        return getOutput();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue) {
+    switch (featureID) {
+      case ProcessorPackage.VARIABLES__INPUT:
+        setInput((String) newValue);
+        return;
+      case ProcessorPackage.VARIABLES__OUTPUT:
+        setOutput((String) newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+      case ProcessorPackage.VARIABLES__INPUT:
+        setInput(INPUT_EDEFAULT);
+        return;
+      case ProcessorPackage.VARIABLES__OUTPUT:
+        setOutput(OUTPUT_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+      case ProcessorPackage.VARIABLES__INPUT:
+        return INPUT_EDEFAULT == null ? input != null : !INPUT_EDEFAULT.equals(input);
+      case ProcessorPackage.VARIABLES__OUTPUT:
+        return OUTPUT_EDEFAULT == null ? output != null : !OUTPUT_EDEFAULT.equals(output);
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String toString() {
+    if (eIsProxy()) {
+      return super.toString();
     }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return ProcessorPackage.Literals.VARIABLES;
+    StringBuffer result = new StringBuffer(super.toString());
+    result.append(" (input: ");
+    result.append(input);
+    result.append(", output: ");
+    result.append(output);
+    result.append(')');
+    return result.toString();
+  }
+
+  /**
+   * @see ExtensionElementImpl#createFixedElement(Document)
+   */
+  @Override
+  protected Element createFixedElement(Document document) {
+    Element element = document.createElementNS(ProcessorPackage.eNS_URI, ProcessorConstants.ELEMENT_VARIABLES);
+    element.setPrefix(ProcessorPackage.eNS_PREFIX);
+    if (input != null) {
+      element.setAttribute(ProcessorConstants.ATT_INPUT, input);
     }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getInput()
-    {
-        return input;
+    if (output != null) {
+      element.setAttribute(ProcessorConstants.ATT_OUTPUT, output);
     }
+    return element;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setInput(String newInput)
-    {
-        String oldInput = input;
-        input = newInput;
-
-        if (!isReconciling
-                && !isUpdatingDOM()
-                && ((getContainer() instanceof InvokePipeletImpl && ((InvokePipeletImpl) getContainer()).fixContent()) || (getContainer() instanceof InvokeServiceImpl && ((InvokeServiceImpl) getContainer())
-                        .fixContent())))
-        {
-            ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_INPUT, newInput);
-        }
-
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.VARIABLES__INPUT, oldInput, input));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getOutput()
-    {
-        return output;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setOutput(String newOutput)
-    {
-        String oldOutput = output;
-        output = newOutput;
-
-        if (!isReconciling
-                && !isUpdatingDOM()
-                && ((getContainer() instanceof InvokePipeletImpl && ((InvokePipeletImpl) getContainer()).fixContent()) || (getContainer() instanceof InvokeServiceImpl && ((InvokeServiceImpl) getContainer())
-                        .fixContent())))
-        {
-            ReconciliationHelper.replaceAttribute(this, ProcessorConstants.ATT_OUTPUT, newOutput);
-        }
-
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, ProcessorPackage.VARIABLES__OUTPUT, oldOutput, output));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.VARIABLES__INPUT :
-                return getInput();
-            case ProcessorPackage.VARIABLES__OUTPUT :
-                return getOutput();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.VARIABLES__INPUT :
-                setInput((String) newValue);
-                return;
-            case ProcessorPackage.VARIABLES__OUTPUT :
-                setOutput((String) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.VARIABLES__INPUT :
-                setInput(INPUT_EDEFAULT);
-                return;
-            case ProcessorPackage.VARIABLES__OUTPUT :
-                setOutput(OUTPUT_EDEFAULT);
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case ProcessorPackage.VARIABLES__INPUT :
-                return INPUT_EDEFAULT == null ? input != null : !INPUT_EDEFAULT.equals(input);
-            case ProcessorPackage.VARIABLES__OUTPUT :
-                return OUTPUT_EDEFAULT == null ? output != null : !OUTPUT_EDEFAULT.equals(output);
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String toString()
-    {
-        if (eIsProxy())
-        {
-            return super.toString();
-        }
-
-        StringBuffer result = new StringBuffer(super.toString());
-        result.append(" (input: ");
-        result.append(input);
-        result.append(", output: ");
-        result.append(output);
-        result.append(')');
-        return result.toString();
-    }
-
-} //VariablesImpl
+} // VariablesImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/test/TestInvokePipeletSerializeAndDeserialize.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/test/TestInvokePipeletSerializeAndDeserialize.java
deleted file mode 100644
index d767360..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/test/TestInvokePipeletSerializeAndDeserialize.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.test;
-
-import javax.xml.namespace.QName;
-import javax.xml.parsers.*;
-
-import junit.framework.TestCase;
-
-import org.eclipse.smila.processing.designer.model.processor.InvokePipelet;
-import org.eclipse.smila.processing.designer.model.processor.Property;
-import org.eclipse.smila.processing.designer.model.processor.impl.ProcessorFactoryImpl;
-import org.eclipse.smila.processing.designer.model.processor.util.InvokePipeletDeserializer;
-import org.eclipse.smila.processing.designer.model.processor.util.InvokePipeletSerializer;
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
-
-/**
- * Tests the serialization/deserialization of {@link InvokePipelet}.
- * 
- * Copyright (c) 2010 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- */
-public class TestInvokePipeletSerializeAndDeserialize extends TestCase
-{
-    private static DocumentBuilder documentBuilder;
-    private static Document document;
-
-    static
-    {
-        try
-        {
-            documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-            document = documentBuilder.newDocument();
-        }
-        catch (Exception e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    public void testSerialization() throws ParserConfigurationException
-    {
-        // (1) Prepare InvokePipelet object to serialize
-        InvokePipelet invokePipelet1 = ProcessorFactoryImpl.eINSTANCE.createInvokePipelet();
-
-        invokePipelet1.getPipelet().setClass("test.class");
-
-        invokePipelet1.getVariables().setInput("varInput");
-        invokePipelet1.getVariables().setOutput("varOutput");
-
-        Property pipeletProperty = ProcessorFactoryImpl.eINSTANCE.createProperty();
-        pipeletProperty.setName("propertyName");
-        pipeletProperty.setValue("propertyValue");
-        invokePipelet1.getPipeletConfiguration().getProperties().add(pipeletProperty);
-
-        // (2) SERIALIZE
-        Node parentNode = document.createElement("extensionActivity");
-        QName elementType = new QName("http://eclipse.org/smila/processor", "invokePipelet", "proc");
-        InvokePipeletSerializer invokePipeletSerializer = new InvokePipeletSerializer();
-        invokePipeletSerializer.marshall(elementType, invokePipelet1, parentNode, null, null);
-
-        // (3) DESERIALIZE
-        InvokePipeletDeserializer invokePipeletDeserializer = new InvokePipeletDeserializer();
-        InvokePipelet invokePipelet2 =
-                (InvokePipelet) invokePipeletDeserializer.unmarshall(elementType, parentNode.getFirstChild(), null, null, null,
-                        null, null, null);
-
-        // (4) Compare
-        assertEquals(invokePipelet1, invokePipelet2);
-    }
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/test/TestInvokeServiceSerializeAndDeserialize.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/test/TestInvokeServiceSerializeAndDeserialize.java
deleted file mode 100644
index d8daabe..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/test/TestInvokeServiceSerializeAndDeserialize.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.test;
-
-import javax.xml.namespace.QName;
-import javax.xml.parsers.*;
-
-import junit.framework.TestCase;
-
-import org.eclipse.smila.processing.designer.model.processor.InvokeService;
-import org.eclipse.smila.processing.designer.model.processor.impl.ProcessorFactoryImpl;
-import org.eclipse.smila.processing.designer.model.processor.util.InvokeServiceDeserializer;
-import org.eclipse.smila.processing.designer.model.processor.util.InvokeServiceSerializer;
-import org.eclipse.smila.processing.designer.model.record.*;
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
-
-/**
- * Tests the serialization/deserialization of {@link InvokeService}.
- * 
- * Copyright (c) 2010 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- */
-public class TestInvokeServiceSerializeAndDeserialize extends TestCase
-{
-    private static DocumentBuilder documentBuilder;
-    private static Document document;
-
-    static
-    {
-        try
-        {
-            documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-            document = documentBuilder.newDocument();
-        }
-        catch (Exception e)
-        {
-            e.printStackTrace();
-        }
-    }
-
-    public void testSerialization() throws ParserConfigurationException
-    {
-        // (1) Prepare InvokeService object to serialize
-        InvokeService invokeService1 = ProcessorFactoryImpl.eINSTANCE.createInvokeService();
-
-        invokeService1.getService().setName("service.name");
-
-        invokeService1.getVariables().setInput("var.input");
-        invokeService1.getVariables().setOutput("var.output");
-
-        Annotation annotation = RecordFactory.eINSTANCE.createAnnotation();
-        annotation.setName("annotation.name");
-        AnnotationValue annotationValue = RecordFactory.eINSTANCE.createAnnotationValue();
-        annotationValue.setName("name.value.1");
-        annotationValue.setValue("value.value.1");
-        annotation.getAnnotationValues().add(annotationValue);
-        invokeService1.getSetAnnotations().getAnnotations().add(annotation);
-
-        // (2) SERIALIZE
-        Node parentNode = document.createElement("extensionActivity");
-        QName elementType = new QName("http://eclipse.org/smila/processor", "invokeService", "proc");
-        InvokeServiceSerializer invokeServiceSerializer = new InvokeServiceSerializer();
-        invokeServiceSerializer.marshall(elementType, invokeService1, parentNode, null, null);
-
-        // (3) DESERIALIZE
-        InvokeServiceDeserializer invokeServiceDeserializer = new InvokeServiceDeserializer();
-        InvokeService invokeService2 =
-                (InvokeService) invokeServiceDeserializer.unmarshall(elementType, parentNode.getFirstChild(), null, null, null,
-                        null, null, null);
-
-        // (4) Compare
-        assertEquals(invokeService1, invokeService2);
-    }
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/AnnotationValueExtensionDeserializer.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/AnnotationValueExtensionDeserializer.java
deleted file mode 100644
index 14fb81d..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/AnnotationValueExtensionDeserializer.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.util;
-
-import java.util.Map;
-
-import javax.wsdl.Definition;
-import javax.wsdl.WSDLException;
-import javax.wsdl.extensions.ExtensibilityElement;
-import javax.wsdl.extensions.ExtensionRegistry;
-import javax.xml.namespace.QName;
-
-import org.eclipse.bpel.model.Process;
-import org.eclipse.bpel.model.extensions.BPELExtensionDeserializer;
-import org.eclipse.bpel.model.resource.BPELReader;
-import org.eclipse.emf.common.util.URI;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-
-/**
- * Deserialiaser for ExtensibilityElement {@link AnnotationValue}.
- * 
- * Copyright (c) 2010 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- */
-public class AnnotationValueExtensionDeserializer implements BPELExtensionDeserializer
-{
-
-    @Override
-    public ExtensibilityElement unmarshall(Class arg0, QName arg1, Element arg2, Definition arg3, ExtensionRegistry arg4)
-            throws WSDLException
-    {
-        System.out.println("NOT yet implemented!");
-        return null;
-    }
-
-    @Override
-    public ExtensibilityElement unmarshall(Class parentType, QName elementType, Node node, Process process, Map nsMap,
-            ExtensionRegistry extReg, URI uri, BPELReader bpelReader) throws WSDLException
-    {
-        System.out.println("NOT yet implemented!");
-        return null;
-    }
-
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/AnnotationValueExtensionSerializer.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/AnnotationValueExtensionSerializer.java
deleted file mode 100644
index 55341a4..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/AnnotationValueExtensionSerializer.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.util;
-
-import java.io.PrintWriter;
-
-import javax.wsdl.Definition;
-import javax.wsdl.WSDLException;
-import javax.wsdl.extensions.ExtensibilityElement;
-import javax.wsdl.extensions.ExtensionRegistry;
-import javax.xml.namespace.QName;
-
-import org.eclipse.bpel.model.Process;
-import org.eclipse.bpel.model.extensions.BPELExtensionSerializer;
-import org.eclipse.bpel.model.resource.BPELWriter;
-import org.eclipse.smila.processing.designer.model.record.AnnotationValue;
-import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
-import org.eclipse.smila.processing.designer.model.record.util.RecordUtils;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-
-/**
- * Serialiaser for ExtensibilityElement {@link AnnotationValue}.
- * 
- * Copyright (c) 2010 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- */
-public class AnnotationValueExtensionSerializer implements BPELExtensionSerializer
-{
-    @Override
-    public void marshall(Class arg0, QName arg1, ExtensibilityElement arg2, PrintWriter arg3, Definition arg4,
-            ExtensionRegistry arg5) throws WSDLException
-    {
-        System.out.println("NOT yet implemented!");
-    }
-
-    @Override
-    public void marshall(Class parentType, QName elementType, ExtensibilityElement extension, Node parentNode, Process process,
-            ExtensionRegistry extReg, BPELWriter bpelWriter) throws WSDLException
-    {
-        AnnotationValue annotationValue = (AnnotationValue) extension;
-        Element elementAnnotationValue =
-                parentNode.getOwnerDocument().createElementNS(elementType.getNamespaceURI(), RecordConstants.NODE_V);
-        elementAnnotationValue.setPrefix(RecordUtils.addNamespace(process));
-        elementAnnotationValue.setAttribute(RecordConstants.ATT_N, annotationValue.getName());
-        elementAnnotationValue.appendChild(parentNode.getOwnerDocument().createTextNode(annotationValue.getValue()));
-        parentNode.appendChild(elementAnnotationValue);
-    }
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/DOMUtils.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/DOMUtils.java
index 6d12ebf..55fbed4 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/DOMUtils.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/DOMUtils.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
@@ -17,225 +16,264 @@
  * 
  * @author Lars Kunze, Tobias Liefke
  */
-public class DOMUtils
-{
-    /** As long as the BPEL designer is using 4 spaces for indentation, we do as well. */
-    private static final int INDENT_SIZE = 4;
+public class DOMUtils {
+  /** As long as the BPEL designer is using 4 spaces for indentation, we do as well. */
+  private static final int INDENT_SIZE = 4;
 
-    /**
-     * Reads the text content of the given {@link Element}.
-     * 
-     * Needed, as the current implementation of {@link Node#getTextContent()} is not implemented.
-     *
-     * @param element The node from which the textContent should be read
-     * @return the text content or the empty string
-     */
-    public static String readTextContent(Element element)
-    {
-        StringBuilder textContent = new StringBuilder();
+  /**
+   * Reads the text content of the given {@link Element}.
+   * 
+   * Needed, as the current implementation of {@link Node#getTextContent()} is not implemented.
+   * 
+   * @param element
+   *          The node from which the textContent should be read
+   * @return the text content or the empty string
+   */
+  public static String readTextContent(Element element) {
+    StringBuilder textContent = new StringBuilder();
 
-        for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling())
-        {
-            if (child instanceof Text)
-            {
-                textContent.append(child.getNodeValue());
-            }
-        }
-
-        return textContent.toString();
+    for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling()) {
+      if (child instanceof Text) {
+        textContent.append(child.getNodeValue());
+      }
     }
 
-    /**
-     * Writes the text content for the given {@link Element}.
-     * 
-     * Replaces all previous existing text nodes.
-     * 
-     * @param element the element to write the text to
-     * @param text the new text content of the element
-     */
-    public static void writeTextContent(Element element, String text)
-    {
-        for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling())
-        {
-            if (child instanceof Text || child instanceof CDATASection)
-            {
-                // Set new content
-                child.setNodeValue(text);
+    return textContent.toString();
+  }
 
-                // And remove all other text nodes
-                while (child != null)
-                {
-                    Node node = child;
-                    child = child.getNextSibling();
-                    if (node instanceof Text || node instanceof CDATASection)
-                    {
-                        element.removeChild(child);
-                    }
-                }
-                return;
-            }
+  /**
+   * Writes the text content for the given {@link Element}.
+   * 
+   * Replaces all previous existing text nodes.
+   * 
+   * @param element
+   *          the element to write the text to
+   * @param text
+   *          the new text content of the element
+   */
+  public static void writeTextContent(Element element, String text) {
+    for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling()) {
+      if (child instanceof Text || child instanceof CDATASection) {
+        // Set new content
+        child.setNodeValue(text);
+
+        // And remove all other text nodes
+        while (child != null) {
+          Node node = child;
+          child = child.getNextSibling();
+          if (node instanceof Text || node instanceof CDATASection) {
+            element.removeChild(child);
+          }
         }
-
-        // No text nodes -> Add as new node
-        element.appendChild(element.getOwnerDocument().createTextNode(text));
+        return;
+      }
     }
 
-    /**
-     * Finds the next element.
-     * 
-     * @param node the node to start searching
-     * @return the node, if it is an element, else the next sibling node that is an element, {@code null} if none exists
-     */
-    public static Element getNextElement(Node node)
-    {
-        while (node != null)
-        {
-            node = node.getNextSibling();
-            if (node instanceof Element)
-            {
-                return (Element) node;
-            }
-        }
-        return null;
-    }
+    // No text nodes -> Add as new node
+    element.appendChild(element.getOwnerDocument().createTextNode(text));
+  }
 
-    /**
-     * Finds all (direct) child elements with the given namespace and local name.
-     * 
-     * @param parentElement the element to search in
-     * @param namespaceURI the URI of the namespace of {@code null} to ignore namespaces
-     * @param localName the (local) name of the elements
-     * @return all child elements that match the given criterias or an empty list if no such element exists
-     */
-    public static List<Element> getChildElements(Element parentElement, String namespaceURI, String localName)
-    {
-        List<Element> result = null;
-        for (Node child = parentElement.getFirstChild(); child != null; child = child.getNextSibling())
-        {
-            if (child instanceof Element)
-            {
-                Element element = (Element) child;
-                if ((namespaceURI == null || namespaceURI.equals(element.getNamespaceURI()))
-                        && localName.equals(element.getLocalName()))
-                {
-                    if (result == null)
-                    {
-                        result = new ArrayList<Element>();
-                    }
-                    result.add(element);
-                }
-            }
-        }
-        if (result == null)
-        {
-            result = Collections.emptyList();
-        }
-        return result;
+  /**
+   * Finds the next element.
+   * 
+   * @param node
+   *          the node to start searching
+   * @return the node, if it is an element, else the next sibling node that is an element, {@code null} if none exists
+   */
+  public static Element getNextElement(Node node) {
+    while (node != null) {
+      node = node.getNextSibling();
+      if (node instanceof Element) {
+        return (Element) node;
+      }
     }
+    return null;
+  }
 
-    /**
-     * Add a new child element to a parent element with correct indentation applied.
-     * 
-     * The child is added to the end of the elements.
-     *
-     * @param parent the parent element
-     * @param child the child element
-     */
-    public static final void appendIndented(Node parent, Node child)
-    {
-        insertIndented(parent, child, null);
+  /**
+   * Finds all (direct) child elements with the given namespace and local name.
+   * 
+   * @param parentElement
+   *          the element to search in
+   * @param namespaceURI
+   *          the URI of the namespace of {@code null} to ignore namespaces
+   * @param localNames
+   *          the (local) names of the elements, leave empty to return all elements (from namespace)
+   * @return all child elements that match the given criterias or an empty list if no such element exists
+   */
+  public static List<Element> getChildElements(Element parentElement, String namespaceURI, String... localNames) {
+    List<Element> result = null;
+    Collection<String> names;
+    if (localNames == null || localNames.length == 0) {
+      names = Collections.emptyList();
+    } else {
+      names = Arrays.asList(localNames);
     }
+    for (Node child = parentElement.getFirstChild(); child != null; child = child.getNextSibling()) {
+      if (child instanceof Element) {
+        Element element = (Element) child;
+        if ((namespaceURI == null || namespaceURI.equals(element.getNamespaceURI()))
+          && (names.isEmpty() || names.contains(element.getLocalName()))) {
+          if (result == null) {
+            result = new ArrayList<Element>();
+          }
+          result.add(element);
+        }
+      }
+    }
+    if (result == null) {
+      result = Collections.emptyList();
+    }
+    return result;
+  }
 
-    /**
-     * Add a new child element to a parent element with correct indentation applied.
-     *
-     * @param parent the parent element
-     * @param child the child element
-     * @param before the existing child element that should follow the current element ({@code null} to add at the end)
-     */
-    public static final void insertIndented(Node parent, Node child, Node before)
-    {
-        // First of all determine indentation of previous element
-        Document document = parent.getOwnerDocument();
-        Node previous = before == null ? parent.getLastChild() : before.getPreviousSibling();
-        if (previous == null)
-        {
-            // No content, indent before and after new element
-            int indent = calculateIndention(parent);
-            Text text = document.createTextNode(createIndent(before != null ? indent + INDENT_SIZE : indent));
-            parent.insertBefore(text, before);
-            parent.insertBefore(child, text);
-            parent.insertBefore(document.createTextNode(createIndent(indent + INDENT_SIZE)), child);
+  /**
+   * Finds the first child element with the given namespace and local name.
+   * 
+   * @param parentElement
+   *          the element to search in
+   * @param namespaceURI
+   *          the URI of the namespace of {@code null} to ignore namespaces
+   * @param localName
+   *          the (local) name of the element
+   * @return the first child element that matches the given criterias or {@code null} if no such element exists
+   */
+  public static Element getChildElement(Element parentElement, String namespaceURI, String localName) {
+    for (Node child = parentElement.getFirstChild(); child != null; child = child.getNextSibling()) {
+      if (child instanceof Element) {
+        Element element = (Element) child;
+        if ((namespaceURI == null || namespaceURI.equals(element.getNamespaceURI()))
+          && localName.equals(element.getLocalName())) {
+          return element;
         }
-        else
-        {
-            // Just indent new element
-            while (!(previous instanceof Element) && previous != null)
-            {
-                previous = previous.getPreviousSibling();
-            }
-            int indent;
-            if (previous == null)
-            {
-                // Use indention of parent
-                indent = calculateIndention(parent) + INDENT_SIZE;
-                parent.insertBefore(child, parent.getFirstChild());
-            }
-            else
-            {
-                // Use indention of previous element
-                indent = calculateIndention(previous);
-                parent.insertBefore(child, previous.getNextSibling());
-            }
-            parent.insertBefore(document.createTextNode(createIndent(indent)), child);
-        }
+      }
     }
+    return null;
+  }
 
-    /**
-     * Calculates the current indention of the given node.
-     * 
-     * Counts the characters in all previous text nodes until the last newline.
-     */
-    private static int calculateIndention(Node node)
-    {
-        int indent = 0;
-        while (node != null)
-        {
-            for (Node previous = node.getPreviousSibling(); previous != null; previous = previous.getPreviousSibling())
-            {
-                if (previous instanceof Text)
-                {
-                    String text = previous.getNodeValue();
-                    // Check all chararcters for newline or tabs
-                    for (int i = text.length() - 1; i >= 0; i--)
-                    {
-                        switch (text.charAt(i))
-                        {
-                            case '\n' :
-                                return indent;
-                            case '\t' :
-                                indent += INDENT_SIZE;
-                            case '\r' :
-                                // Ignore
-                                break;
-                            default :
-                                indent++;
-                        }
-                    }
-                }
-            }
-            node = node.getParentNode();
-        }
-        return indent;
-    }
+  /**
+   * Add a new child element to a parent element with correct indentation applied.
+   * 
+   * The child is added to the end of the elements.
+   * 
+   * @param parent
+   *          the parent element
+   * @param child
+   *          the child element
+   */
+  public static final void appendIndented(Node parent, Node child) {
+    insertIndented(parent, child, null);
+  }
 
-    private static final String createIndent(int size)
-    {
-        StringBuilder result = new StringBuilder(size + 1).append('\n');
-        while (size-- > 0)
-        {
-            result.append(' ');
-        }
-        return result.toString();
+  /**
+   * Add a new child element to a parent element with correct indentation applied.
+   * 
+   * @param parent
+   *          the parent element
+   * @param child
+   *          the child element
+   * @param before
+   *          the existing child element that should follow the current element ({@code null} to add at the end)
+   */
+  public static final void insertIndented(Node parent, Node child, Node before) {
+    // First of all determine indentation of previous element
+    Document document = parent.getOwnerDocument();
+    Node previous = before == null ? parent.getLastChild() : before.getPreviousSibling();
+    if (previous == null) {
+      // No content, indent before and after new element
+      int indent = calculateIndention(parent);
+      Text text = document.createTextNode(createIndent(before != null ? indent + INDENT_SIZE : indent));
+      parent.insertBefore(text, before);
+      parent.insertBefore(child, text);
+      parent.insertBefore(document.createTextNode(createIndent(indent + INDENT_SIZE)), child);
+    } else {
+      // Just indent new element
+      while (!(previous instanceof Element) && previous != null) {
+        previous = previous.getPreviousSibling();
+      }
+      int indent;
+      if (previous == null) {
+        // Use indention of parent
+        indent = calculateIndention(parent) + INDENT_SIZE;
+        parent.insertBefore(child, parent.getFirstChild());
+      } else {
+        // Use indention of previous element
+        indent = calculateIndention(previous);
+        parent.insertBefore(child, previous.getNextSibling());
+      }
+      parent.insertBefore(document.createTextNode(createIndent(indent)), child);
     }
+  }
+
+  /**
+   * Removes a child element from its parent element with correct indentation applied.
+   * 
+   * @param child
+   *          the child element to remove
+   */
+  public static final void removeIndented(Node child) {
+    Node parent = child.getParentNode();
+    // Remove all directly preceding whitespace nodes
+    while (isWhitespaceText(child.getPreviousSibling())) {
+      parent.removeChild(child.getPreviousSibling());
+    }
+    parent.removeChild(child);
+  }
+
+  /**
+   * Indicates that the node is a text node that contains whitespaces only.
+   */
+  private static final boolean isWhitespaceText(Node node) {
+    if (node instanceof Text) {
+      String text = node.getNodeValue();
+      for (int i = text.length() - 1; i >= 0; i--) {
+        if (!Character.isWhitespace(text.charAt(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Calculates the current indention of the given node.
+   * 
+   * Counts the characters in all previous text nodes until the last newline.
+   */
+  private static int calculateIndention(Node node) {
+    int indent = 0;
+    while (node != null) {
+      for (Node previous = node.getPreviousSibling(); previous != null; previous = previous.getPreviousSibling()) {
+        if (previous instanceof Text) {
+          String text = previous.getNodeValue();
+          // Check all chararcters for newline or tabs
+          for (int i = text.length() - 1; i >= 0; i--) {
+            switch (text.charAt(i)) {
+              case '\n':
+                return indent;
+              case '\t':
+                indent += INDENT_SIZE;
+              case '\r':
+                // Ignore
+                break;
+              default:
+                indent++;
+            }
+          }
+        }
+      }
+      node = node.getParentNode();
+    }
+    return indent;
+  }
+
+  private static final String createIndent(int size) {
+    StringBuilder result = new StringBuilder(size + 1).append('\n');
+    while (size-- > 0) {
+      result.append(' ');
+    }
+    return result.toString();
+  }
+
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletDeserializer.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletDeserializer.java
index b5645ee..c6fcc42 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletDeserializer.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletDeserializer.java
@@ -1,12 +1,12 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
-import java.util.Map;
+import java.text.ParseException;
+import java.util.*;
 
 import javax.wsdl.extensions.ExtensionRegistry;
 import javax.xml.namespace.QName;
@@ -18,6 +18,9 @@
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.smila.processing.designer.model.processor.*;
+import org.eclipse.smila.processing.designer.model.record.*;
+import org.eclipse.smila.processing.designer.model.record.RecordVal.Type;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 
@@ -28,126 +31,243 @@
  * 
  * @author Lars Kunze
  */
-public class InvokePipeletDeserializer implements BPELActivityDeserializer
-{
-    @Override
-    public Activity unmarshall(QName elementType, Node node, Activity activity, Process process,
-            @SuppressWarnings("rawtypes") Map nsMap, ExtensionRegistry extReg, URI uri, BPELReader bpelReader)
-    {
-        if (ProcessorConstants.NODE_INVOKE_PIPELET.equals(elementType.getLocalPart()) && node instanceof Element)
-        {
-            Element invokePipeletElement = (Element) node;
-            InvokePipelet invokePipelet;
+public class InvokePipeletDeserializer implements BPELActivityDeserializer {
+  @Override
+  public Activity unmarshall(QName elementType, Node node, Activity activity, Process process,
+    @SuppressWarnings("rawtypes") Map nsMap, ExtensionRegistry extReg, URI uri, BPELReader bpelReader) {
+    if (ProcessorConstants.ELEMENT_INVOKE_PIPELET.equals(elementType.getLocalPart())
+      && ProcessorConstants.NS_URI.equals(elementType.getNamespaceURI()) && node instanceof Element) {
+      Element invokePipeletElement = (Element) node;
+      InvokePipelet invokePipelet;
 
-            if (activity instanceof InvokePipelet)
-            {
-                // Use the existing model object
-                invokePipelet = (InvokePipelet) activity;
-            }
-            else
-            {
-                // Create a new InvokePipelet model object
-                invokePipelet = ProcessorFactory.eINSTANCE.createInvokePipelet();
+      if (activity instanceof InvokePipelet) {
+        // Use the existing model object
+        invokePipelet = (InvokePipelet) activity;
+      } else {
+        // Create a new InvokePipelet model object
+        invokePipelet = ProcessorFactory.eINSTANCE.createInvokePipelet();
+      }
+      invokePipelet.setElement((Element) invokePipeletElement.getParentNode());
 
-                // Attach the DOM node to our new InvokePipelet activity
-                invokePipelet.setElement(invokePipeletElement);
-            }
-
-            // Disconnect any known elements
-            invokePipelet.getPipelet().setElement(null);
-            invokePipelet.getPipelet().setClass("");
-            invokePipelet.getVariables().setElement(null);
-            invokePipelet.getVariables().setInput("");
-            invokePipelet.getVariables().setOutput("");
-            invokePipelet.getPipeletConfiguration().setElement(null);
-            invokePipelet.getPipeletConfiguration().getProperties().clear();
-
-            // Handle the child nodes
-            for (Node child = invokePipeletElement.getFirstChild(); child != null; child = child.getNextSibling())
-            {
-                if (child instanceof Element)
-                {
-                    Element element = (Element) child;
-                    if (ProcessorConstants.NODE_PIPELET.equals(element.getLocalName()))
-                    {
-                        // (a) Handle node 'pipelet'
-                        String attributeClass = element.getAttribute(ProcessorConstants.ATT_CLASS);
-                        invokePipelet.getPipelet().setClass(attributeClass);
-                        invokePipelet.getPipelet().setElement(element);
-                    }
-                    else if (ProcessorConstants.NODE_VARIABLES.equals(element.getLocalName()))
-                    {
-                        // (b) Handle node 'variables'
-                        invokePipelet.getVariables().setInput(element.getAttribute(ProcessorConstants.ATT_INPUT));
-                        invokePipelet.getVariables().setOutput(element.getAttribute(ProcessorConstants.ATT_OUTPUT));
-                        invokePipelet.getVariables().setElement(element);
-                    }
-                    else if (ProcessorConstants.NODE_PIPELET_CONFIGURATION.equals(element.getLocalName()))
-                    {
-                        // (c) Handle node 'pipeletConfiguration'
-                        readPipeletConfiguration(invokePipelet, element);
-                    }
-                }
-            }
-
-            return invokePipelet;
+      // (a) Handle node 'pipelet'
+      Element pipeletElement =
+        DOMUtils.getChildElement(invokePipeletElement, ProcessorConstants.NS_URI,
+          ProcessorConstants.ELEMENT_PIPELET);
+      if (pipeletElement == null) {
+        invokePipelet.setPipelet(null);
+      } else {
+        Pipelet pipelet = invokePipelet.getPipelet();
+        if (pipelet == null) {
+          pipelet = ProcessorFactory.eINSTANCE.createPipelet();
         }
-
-        System.err.println("Cannot handle this kind of element");
-        return null;
-    }
-
-    /**
-     * Reads the pipelet configuration element for the given pipelet.
-     * 
-     * @param invokePipelet the pipelet
-     * @param configurationElement the DOM element representation of the configuration
-     */
-    private void readPipeletConfiguration(InvokePipelet invokePipelet, Element configurationElement)
-    {
-        PipeletConfiguration configuration = invokePipelet.getPipeletConfiguration();
-
-        // Read the properties
-        EList<Property> properties = configuration.getProperties();
-        for (Node child = configurationElement.getFirstChild(); child != null; child = child.getNextSibling())
-        {
-            if (child instanceof Element)
-            {
-                Element element = (Element) child;
-                String propertyName = element.getAttribute(ProcessorConstants.ATT_NAME);
-                if (propertyName.length() > 0)
-                {
-                    Property property = ProcessorFactory.eINSTANCE.createProperty();
-                    property.setName(propertyName);
-                    property.setValue(readPropertyValue(element));
-                    property.setElement(element);
-                    properties.add(property);
-                }
-                else
-                {
-                    System.err.println("property attribute 'name' is null or empty!");
-                }
-            }
+        if (pipeletElement != pipelet.getElement()) {
+          pipelet.setElement(pipeletElement);
         }
+        pipelet.setClass(pipeletElement.getAttribute(ProcessorConstants.ATT_CLASS));
+        if (invokePipelet.getPipelet() != pipelet) {
+          invokePipelet.setPipelet(pipelet);
+        }
+      }
+
+      // (b) Handle node 'variables'
+      Element variablesElement =
+        DOMUtils.getChildElement(invokePipeletElement, ProcessorConstants.NS_URI,
+          ProcessorConstants.ELEMENT_VARIABLES);
+      if (variablesElement == null) {
+        invokePipelet.setVariables(null);
+      } else {
+        Variables variables = invokePipelet.getVariables();
+        if (variables == null) {
+          variables = ProcessorFactory.eINSTANCE.createVariables();
+        }
+        if (variablesElement != variables.getElement()) {
+          variables.setElement(pipeletElement);
+        }
+        variables.setInput(variablesElement.getAttribute(ProcessorConstants.ATT_INPUT));
+        variables.setOutput(variablesElement.getAttribute(ProcessorConstants.ATT_OUTPUT));
+        if (invokePipelet.getVariables() != variables) {
+          invokePipelet.setVariables(variables);
+        }
+      }
+
+      // (c) Handle node 'configuration'
+      Configuration configuration = invokePipelet.getConfiguration();
+      if (configuration == null) {
+        configuration = ProcessorFactory.eINSTANCE.createConfiguration();
+      }
+
+      Element configurationElement =
+        DOMUtils.getChildElement(invokePipeletElement, ProcessorConstants.NS_URI,
+          ProcessorConstants.ELEMENT_CONFIGURATION);
+      if (configurationElement != configuration.getElement()) {
         configuration.setElement(configurationElement);
+      }
+      if (configurationElement == null) {
+        // No element found
+        configuration.getValues().clear();
+      } else {
+        // Read the values
+        readMap(configurationElement, configuration);
+      }
+      if (invokePipelet.getConfiguration() != configuration) {
+        invokePipelet.setConfiguration(configuration);
+      }
+
+      return invokePipelet;
     }
 
-    /**
-     * Reads the text content of the first proc:Value element.
-     *
-     * @param propertyElement the parent element
-     * @return the text content or the empty string
-     */
-    private String readPropertyValue(Element propertyElement)
-    {
-        for (Node child = propertyElement.getFirstChild(); child != null; child = child.getNextSibling())
-        {
-            if (child instanceof Element && ProcessorConstants.NODE_VALUE.equals(child.getLocalName()))
-            {
-                return DOMUtils.readTextContent((Element) child);
-            }
+    System.err.println("Cannot handle this kind of element");
+    return null;
+  }
+
+  /**
+   * Reads a value map.
+   * 
+   * @param element
+   *          the XML element of the map
+   * @param map
+   *          the map to fill
+   * @return the filled map
+   */
+  private RecordMap readMap(Element element, RecordMap map) {
+    readValues(element, map, true);
+    return map;
+  }
+
+  /**
+   * Reads a sequence.
+   * 
+   * @param element
+   *          the XML element of the sequence
+   * @param seq
+   *          the sequence to fill
+   * @return the filled sequence
+   */
+  private RecordSeq readSeq(Element element, RecordSeq seq) {
+    readValues(element, seq, false);
+    return seq;
+  }
+
+  private void readValues(Element element, RecordValues parent, boolean readKeys) {
+    if (parent.getElement() != element) {
+      parent.setElement(element);
+    }
+    EList<RecordAny> values = parent.getValues();
+    // Remove all old values and create index elements
+    List<Element> elements = new ArrayList<Element>();
+    for (Iterator<RecordAny> it = values.iterator(); it.hasNext();) {
+      Element oldElement = it.next().getElement();
+      if (oldElement == null || oldElement.getParentNode() != element) {
+        it.remove();
+      } else {
+        elements.add(oldElement);
+      }
+    }
+
+    // Add new / sort existing values
+    int currentIndex = 0;
+    for (Node child = element.getFirstChild(); child != null; child = child.getNextSibling()) {
+      if (child instanceof Element) {
+        RecordAny value;
+        Element childElement = (Element) child;
+        int index = elements.indexOf(childElement);
+        if (index < 0) {
+          // New element
+          value = createValue(childElement);
+          if (value == null) {
+            continue;
+          }
+          values.add(currentIndex, value);
+          elements.add(currentIndex, childElement);
+        } else {
+          // Existing element
+          value = values.get(index);
+          if (index > currentIndex) {
+            values.move(currentIndex, index);
+            elements.remove(index);
+            elements.add(currentIndex, childElement);
+          }
+          readValue(value);
         }
-
-        return "";
+        currentIndex++;
+        String key = childElement.getAttribute(RecordConstants.ATT_KEY);
+        if (key.length() > 0) {
+          if (!key.equals(value.getKey())) {
+            value.setKey(key);
+          }
+          if (!readKeys) {
+            System.err.println("Found sequence value with key!");
+          }
+        } else {
+          if (value.getKey() != null) {
+            value.setKey(null);
+          }
+          if (readKeys) {
+            System.err.println("Found map value without key!");
+          }
+        }
+      }
     }
+  }
+
+  private RecordAny readVal(Element element, RecordVal val) {
+    if (element != val.getElement()) {
+      val.setElement(element);
+    }
+    String type = element.getAttribute(RecordConstants.ATT_TYPE);
+    Type valueType;
+    if (type.length() == 0) {
+      valueType = Type.STRING;
+    } else {
+      try {
+        valueType = Type.valueOf(type.toUpperCase());
+      } catch (IllegalArgumentException e) {
+        System.err.println("Unkonwn type: " + type);
+        valueType = Type.STRING;
+      }
+    }
+    String textContent = DOMUtils.readTextContent(element);
+    try {
+      Object object = valueType.parse(textContent);
+      if (object != val.getValue() && (object == null || !object.equals(val.getValue()))) {
+        val.setValue(object);
+      }
+    } catch (ParseException e) {
+      System.err.println("Could not parse text content for type \"" + valueType + "\": " + textContent);
+      // val.setValue(textContent);
+    }
+    return val;
+  }
+
+  /**
+   * Reads a value from the given XML element.
+   */
+  private RecordAny createValue(Element element) {
+    if (RecordConstants.NS_URI.equals(element.getNamespaceURI())) {
+      if (RecordConstants.ELEMENT_MAP.equals(element.getLocalName())) {
+        return readMap(element, RecordFactory.eINSTANCE.createRecordMap());
+      } else if (RecordConstants.ELEMENT_SEQ.equals(element.getLocalName())) {
+        return readSeq(element, RecordFactory.eINSTANCE.createRecordSeq());
+      } else if (RecordConstants.ELEMENT_VAL.equals(element.getLocalName())) {
+        return readVal(element, RecordFactory.eINSTANCE.createRecordVal());
+      }
+    }
+
+    System.err.println("Unknown record element: " + element.getNodeName());
+    return null;
+  }
+
+  /**
+   * Reads a value from the given XML element.
+   */
+  private void readValue(RecordAny value) {
+    if (value.isMap()) {
+      readMap(value.getElement(), (RecordMap) value);
+    } else if (value.isSeq()) {
+      readSeq(value.getElement(), (RecordSeq) value);
+    } else if (value.isVal()) {
+      readVal(value.getElement(), (RecordVal) value);
+    }
+  }
+
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletSerializer.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletSerializer.java
index b7bc04c..071f4d8 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletSerializer.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokePipeletSerializer.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
@@ -13,6 +12,10 @@
 import org.eclipse.bpel.model.extensions.BPELActivitySerializer;
 import org.eclipse.bpel.model.resource.BPELWriter;
 import org.eclipse.smila.processing.designer.model.processor.*;
+import org.eclipse.smila.processing.designer.model.record.*;
+import org.eclipse.smila.processing.designer.model.record.RecordVal.Type;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
+import org.eclipse.smila.processing.designer.model.record.util.RecordUtils;
 import org.w3c.dom.*;
 
 /**
@@ -22,68 +25,95 @@
  * 
  * @author Lars Kunze
  */
-public class InvokePipeletSerializer implements BPELActivitySerializer
-{
-    @Override
-    public void marshall(QName elementType, Activity activity, Node parentNode, Process process, BPELWriter bpelWriter)
-    {
-        Document document = parentNode.getOwnerDocument();
+public class InvokePipeletSerializer implements BPELActivitySerializer {
+  @Override
+  public void marshall(QName elementType, Activity activity, Node parentNode, Process process, BPELWriter bpelWriter) {
+    Document document = parentNode.getOwnerDocument();
 
-        /*
-         * InvokePipelet
-         */
-        if (activity instanceof InvokePipelet)
-        {
-            InvokePipelet invokePipelet = (InvokePipelet) activity;
+    /*
+     * InvokePipelet
+     */
+    if (activity instanceof InvokePipelet) {
+      InvokePipelet invokePipelet = (InvokePipelet) activity;
 
-            // (1) Create a new DOM element for our Activity
-            Element elementInvokePipelet =
-                    document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_INVOKE_PIPELET);
-            elementInvokePipelet.setPrefix(ProcessorUtils.addNamespace(process));
-            parentNode.appendChild(elementInvokePipelet);
-            invokePipelet.setElement(elementInvokePipelet);
+      // (1) Create a new DOM element for our Activity
+      Element elementInvokePipelet =
+        document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.ELEMENT_INVOKE_PIPELET);
+      elementInvokePipelet.setPrefix(ProcessorUtils.addNamespace(process));
+      parentNode.appendChild(elementInvokePipelet);
 
-            // (2) Create child nodes
+      // (2) Create child nodes
 
-            // (a) Node 'pipelet'
-            Pipelet pipelet = invokePipelet.getPipelet();
-            Element elementPipelet = document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_PIPELET);
-            elementPipelet.setPrefix(ProcessorPackage.eNS_PREFIX);
-            String className = pipelet.getClass_();
-            elementPipelet.setAttribute(ProcessorConstants.ATT_CLASS, className == null ? "" : className);
-            elementInvokePipelet.appendChild(elementPipelet);
-            pipelet.setElement(elementPipelet);
+      // (a) Node 'pipelet'
+      Pipelet pipelet = invokePipelet.getPipelet();
+      Element elementPipelet =
+        document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.ELEMENT_PIPELET);
+      elementPipelet.setPrefix(ProcessorPackage.eNS_PREFIX);
+      String className = pipelet.getClass_();
+      elementPipelet.setAttribute(ProcessorConstants.ATT_CLASS, className == null ? "" : className);
+      elementInvokePipelet.appendChild(elementPipelet);
 
-            // (b) Node 'variables'
-            Variables variables = invokePipelet.getVariables();
-            Element elementVariables =
-                    document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_VARIABLES);
-            elementVariables.setPrefix(ProcessorPackage.eNS_PREFIX);
-            elementVariables.setAttribute(ProcessorConstants.ATT_INPUT, variables.getInput());
-            elementVariables.setAttribute(ProcessorConstants.ATT_OUTPUT, variables.getOutput());
-            elementInvokePipelet.appendChild(elementVariables);
-            variables.setElement(elementVariables);
+      // (b) Node 'variables'
+      Variables variables = invokePipelet.getVariables();
+      Element elementVariables =
+        document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.ELEMENT_VARIABLES);
+      elementVariables.setPrefix(ProcessorPackage.eNS_PREFIX);
+      elementVariables.setAttribute(ProcessorConstants.ATT_INPUT, variables.getInput());
+      elementVariables.setAttribute(ProcessorConstants.ATT_OUTPUT, variables.getOutput());
+      elementInvokePipelet.appendChild(elementVariables);
 
-            // (c) Node 'pipeletConfiguration'
-            Element elementPipeletConfiguration =
-                    document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_PIPELET_CONFIGURATION);
-            elementPipeletConfiguration.setPrefix(ProcessorPackage.eNS_PREFIX);
-            elementInvokePipelet.appendChild(elementPipeletConfiguration);
-            for (Property pipeletProperty : invokePipelet.getPipeletConfiguration().getProperties())
-            {
-                Element elementProperty =
-                        document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_PROPERTY);
-                elementProperty.setPrefix(ProcessorPackage.eNS_PREFIX);
-                elementProperty.setAttribute(ProcessorConstants.ATT_NAME, pipeletProperty.getName());
-                Element elementValue = document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_VALUE);
-                elementValue.setPrefix(ProcessorPackage.eNS_PREFIX);
-                elementValue.setTextContent(pipeletProperty.getValue());
-                elementPipeletConfiguration.appendChild(elementProperty);
-                elementProperty.appendChild(elementValue);
-                pipeletProperty.setElement(elementProperty);
-            }
-            invokePipelet.getPipeletConfiguration().setElement(elementPipeletConfiguration);
+      // (c) Node 'pipeletConfiguration'
+      Element elementConfiguration =
+        document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.ELEMENT_CONFIGURATION);
+      elementConfiguration.setPrefix(ProcessorPackage.eNS_PREFIX);
+      elementInvokePipelet.appendChild(elementConfiguration);
 
-        }
+      writeMap(invokePipelet.getConfiguration(), elementConfiguration, process);
     }
+  }
+
+  /**
+   * Writes a map to XML.
+   */
+  private void writeMap(RecordMap map, Element element, Process process) {
+    for (RecordAny value : map.getValues()) {
+      writeValue(value, element, process).setAttribute(RecordConstants.ATT_KEY, value.getKey());
+    }
+  }
+
+  /**
+   * Writes a sequence to XML.
+   */
+  private void writeSeq(RecordSeq seq, Element element, Process process) {
+    for (RecordAny value : seq.getValues()) {
+      writeValue(value, element, process);
+    }
+  }
+
+  /**
+   * Writes a value to XML
+   */
+  private Element writeValue(RecordAny value, Element parent, Process process) {
+    Element element;
+    if (value.isMap()) {
+      element = parent.getOwnerDocument().createElementNS(parent.getNamespaceURI(), RecordConstants.ELEMENT_MAP);
+      writeMap((RecordMap) value, element, process);
+    } else if (value.isSeq()) {
+      element = parent.getOwnerDocument().createElementNS(parent.getNamespaceURI(), RecordConstants.ELEMENT_SEQ);
+      writeSeq((RecordSeq) value, element, process);
+    } else {
+      element = parent.getOwnerDocument().createElementNS(parent.getNamespaceURI(), RecordConstants.ELEMENT_VAL);
+      RecordVal val = (RecordVal) value;
+      Type type = val.getType();
+      if (type != null) {
+        if (type != Type.STRING) {
+          element.setAttribute(RecordConstants.ATT_TYPE, type.toString().toLowerCase());
+        }
+        element.setTextContent(type.format(val.getValue()));
+      }
+    }
+    element.setPrefix(RecordUtils.addNamespace(process));
+    parent.appendChild(element);
+    return element;
+  }
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokeServiceDeserializer.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokeServiceDeserializer.java
deleted file mode 100644
index 112e337..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokeServiceDeserializer.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.util;
-
-import java.util.Map;
-
-import javax.wsdl.extensions.ExtensionRegistry;
-import javax.xml.namespace.QName;
-
-import org.eclipse.bpel.model.Activity;
-import org.eclipse.bpel.model.Process;
-import org.eclipse.bpel.model.extensions.BPELActivityDeserializer;
-import org.eclipse.bpel.model.resource.BPELReader;
-import org.eclipse.emf.common.util.URI;
-import org.eclipse.smila.processing.designer.model.processor.*;
-import org.eclipse.smila.processing.designer.model.record.*;
-import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-
-/**
- * Reads the {@link InvokeService}s from the XML file.
- * 
- * Copyright (c) 2010 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- */
-public class InvokeServiceDeserializer implements BPELActivityDeserializer
-{
-    @Override
-    public Activity unmarshall(QName elementType, Node node, Activity activity, Process process,
-            @SuppressWarnings("rawtypes") Map nsMap, ExtensionRegistry extReg, URI uri, BPELReader bpelReader)
-    {
-        if (ProcessorConstants.NODE_INVOKE_SERVICE.equals(elementType.getLocalPart()))
-        {
-            Element invokeServiceElement = (Element) node;
-
-            InvokeService invokeService;
-            if (activity instanceof InvokeService)
-            {
-                // Use the existing model object
-                invokeService = (InvokeService) activity;
-            }
-            else
-            {
-                // Create a new InvokeService model object
-                invokeService = ProcessorFactory.eINSTANCE.createInvokeService();
-
-                // Attach the DOM node to our new InvokeService activity
-                invokeService.setElement((Element) node);
-            }
-
-            // Handle the child nodes
-            for (Node child = invokeServiceElement.getFirstChild(); child != null; child = child.getNextSibling())
-            {
-                if (child instanceof Element)
-                {
-                    Element element = (Element) child;
-                    if (child.getNodeType() == Node.ELEMENT_NODE)
-                    {
-                        if (ProcessorConstants.NODE_SERVICE.equals(element.getLocalName()))
-                        {
-                            // (a) Handle node 'service'
-                            invokeService.getService().setName(element.getAttribute(ProcessorConstants.ATT_NAME));
-                            invokeService.getService().setElement(element);
-                        }
-                        else if (ProcessorConstants.NODE_VARIABLES.equals(element.getLocalName()))
-                        {
-                            // (b) Handle node 'variables'
-                            invokeService.getVariables().setInput(element.getAttribute(ProcessorConstants.ATT_INPUT));
-                            invokeService.getVariables().setInput(element.getAttribute(ProcessorConstants.ATT_OUTPUT));
-                            invokeService.getVariables().setElement(element);
-                        }
-                        else if (ProcessorConstants.NODE_SET_ANNOTATIONS.equals(element.getLocalName()))
-                        {
-                            // (c) Handle node 'setAnnotations'
-                            SetAnnotations setAnnotations = invokeService.getSetAnnotations();
-                            // Disconnect from old element
-                            setAnnotations.setElement(null);
-                            // Read the new properties
-                            setAnnotations.getAnnotations().clear();
-                            readAnnotations(setAnnotations, null, element);
-                            // And connect to new element
-                            setAnnotations.setElement(element);
-                        }
-                    }
-                }
-            }
-
-            return invokeService;
-        }
-
-        System.out.println("Cannot handle this kind of element");
-        return null;
-    }
-
-    /**
-     * Recursive method to read the 'An' and 'V' nodes.
-     * 
-     * @param setAnnotations The 'setAnnotations' object to which the read 'An' and 'V' nodes have to be added
-     * @param anParent The parent 'an' node
-     * @param nodeList The list of nodes to read
-     */
-    private void readAnnotations(SetAnnotations setAnnotations, Annotation annotationParent, Element elementSetAnnotation)
-    {
-        for (Node child = elementSetAnnotation.getFirstChild(); child != null; child = child.getNextSibling())
-        {
-            if (child instanceof Element)
-            {
-                Element element = (Element) child;
-
-                if (RecordConstants.NODE_AN.equals(element.getLocalName()))
-                {
-                    // Handle node 'An'
-                    String attributeN = element.getAttribute(RecordConstants.ATT_N);
-                    Annotation annotation = RecordFactory.eINSTANCE.createAnnotation();
-                    annotation.setElement(element);
-                    annotation.setName(attributeN);
-                    if (annotationParent == null)
-                    {
-                        annotationParent = annotation;
-                        setAnnotations.getAnnotations().add(annotation);
-                    }
-                    else
-                    {
-                        annotationParent.getAnnotations().add(annotation);
-                    }
-                    if (element.hasChildNodes())
-                    {
-                        readAnnotations(setAnnotations, annotation, element);
-                    }
-                }
-                else if (element.getLocalName().equals(RecordConstants.NODE_V))
-                {
-                    // Handle node 'V'
-                    String attributeN = element.getAttribute(RecordConstants.ATT_N);
-                    AnnotationValue annotationValue = RecordFactory.eINSTANCE.createAnnotationValue();
-                    annotationValue.setElement(element);
-                    annotationValue.setName(attributeN);
-                    annotationValue.setValue(DOMUtils.readTextContent(element));
-                    annotationParent.getAnnotationValues().add(annotationValue);
-                }
-            }
-        }
-
-    }
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokeServiceSerializer.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokeServiceSerializer.java
deleted file mode 100644
index d478712..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/InvokeServiceSerializer.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.processor.util;
-
-import javax.xml.namespace.QName;
-
-import org.eclipse.bpel.model.Activity;
-import org.eclipse.bpel.model.Process;
-import org.eclipse.bpel.model.extensions.BPELActivitySerializer;
-import org.eclipse.bpel.model.resource.BPELWriter;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.smila.processing.designer.model.processor.*;
-import org.eclipse.smila.processing.designer.model.record.Annotation;
-import org.eclipse.smila.processing.designer.model.record.AnnotationValue;
-import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
-import org.eclipse.smila.processing.designer.model.record.util.RecordUtils;
-import org.w3c.dom.*;
-
-/**
- * Creates XML for the {@link InvokeService}s object representation.
- *
- * Copyright (c) 2010 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- */
-public class InvokeServiceSerializer implements BPELActivitySerializer
-{
-
-    @Override
-    public void marshall(QName elementType, Activity activity, Node parentNode, Process process, BPELWriter bpelWriter)
-    {
-        Document document = parentNode.getOwnerDocument();
-
-        /*
-         * InvokeService
-         */
-        if (activity instanceof InvokeService)
-        {
-            InvokeService invokeService = (InvokeService) activity;
-
-            // (1) Create a new DOM element for our Activity
-            Element elementInvokeService =
-                    document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_INVOKE_SERVICE);
-            elementInvokeService.setPrefix(ProcessorUtils.addNamespace(process));
-            invokeService.setElement(elementInvokeService);
-
-            // (2) Create child nodes
-
-            // (a) Node 'service'
-            Service service = invokeService.getService();
-            Element elementService = document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_SERVICE);
-            elementService.setPrefix(ProcessorUtils.addNamespace(process));
-            String name = service.getName();
-            elementService.setAttribute(ProcessorConstants.ATT_NAME, name == null ? "" : name);
-            elementInvokeService.appendChild(elementService);
-            service.setElement(elementService);
-
-            // (b) Node 'variables'
-            Variables variables = invokeService.getVariables();
-            Element elementVariables =
-                    document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_VARIABLES);
-            elementVariables.setPrefix(ProcessorUtils.addNamespace(process));
-            elementVariables.setAttribute(ProcessorConstants.ATT_INPUT, variables.getInput());
-            elementVariables.setAttribute(ProcessorConstants.ATT_OUTPUT, variables.getOutput());
-            elementInvokeService.appendChild(elementVariables);
-            variables.setElement(elementVariables);
-
-            // (c) Node 'setAnnotations'
-            SetAnnotations setAnnotations = invokeService.getSetAnnotations();
-            if (setAnnotations != null)
-            {
-                Element elementSetAnnotations =
-                        document.createElementNS(elementType.getNamespaceURI(), ProcessorConstants.NODE_SET_ANNOTATIONS);
-                elementSetAnnotations.setPrefix(ProcessorUtils.addNamespace(process));
-                elementInvokeService.appendChild(elementSetAnnotations);
-                createSetAnnotationsNode(document, elementType.getNamespaceURI(), elementSetAnnotations,
-                        setAnnotations.getAnnotations(), process);
-                setAnnotations.setElement(elementSetAnnotations);
-            }
-
-            // (d) Add activity 'invokePipelet' to the parentNode
-            parentNode.appendChild(elementInvokeService);
-
-            // Print XML
-            // printXML(document, parentNode);          
-        }
-    }
-
-    /**
-     * Creates the child elements ('An' and 'V') for the 'SetAnnotation' property (recursive method).
-     * 
-     * @param document Document instance for creating new elements
-     * @param namespaceURI The namespaceURI for the new created elements
-     * @param elementParent The parent element to which the new created elements have to be appended
-     * @param annotations The list of annotations of the 'SetAnnotation' property
-     * @param process The model object Process. (Needed for node prefix determination) 
-     */
-    private void createSetAnnotationsNode(Document document, String namespaceURI, Element elementParent,
-            EList<Annotation> annotations, Process process)
-    {
-        for (Annotation annotation : annotations)
-        {
-            if (annotation != null && annotation.getName() != null)
-            {
-                // Node 'An'
-                Element elementAnnotation = document.createElementNS(namespaceURI, RecordConstants.NODE_AN);
-                elementAnnotation.setPrefix(RecordUtils.addNamespace(process));
-                elementAnnotation.setAttribute(RecordConstants.ATT_N, annotation.getName());
-                elementParent.appendChild(elementAnnotation);
-                annotation.setElement(elementAnnotation);
-
-                // Children 'V' of 'An'
-                if (annotation.getAnnotationValues() != null && annotation.getAnnotationValues().size() > 0)
-                {
-                    // Nodes 'V'
-                    for (AnnotationValue annotationValue : annotation.getAnnotationValues())
-                    {
-                        if (annotationValue != null && annotationValue.getName() != null && annotationValue.getValue() != null)
-                        {
-                            Element elementAnnotationValue = document.createElementNS(namespaceURI, RecordConstants.NODE_V);
-                            elementAnnotationValue.setPrefix(RecordUtils.addNamespace(process));
-                            elementAnnotationValue.setAttribute(RecordConstants.ATT_N, annotationValue.getName());
-                            elementAnnotationValue.appendChild(document.createTextNode(annotationValue.getValue()));
-                            elementAnnotation.appendChild(elementAnnotationValue);
-                            annotationValue.setElement(elementAnnotationValue);
-                        }
-                    }
-                }
-
-                // Children 'An' of 'An'
-                if (annotation.getAnnotations() != null && annotation.getAnnotations().size() > 0)
-                {
-                    createSetAnnotationsNode(document, namespaceURI, elementAnnotation, annotation.getAnnotations(), process);
-                }
-            }
-        }
-    }
-
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorAdapterFactory.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorAdapterFactory.java
index bd42945..aabfd9b 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorAdapterFactory.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorAdapterFactory.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
@@ -16,418 +15,369 @@
 import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.smila.processing.designer.model.processor.*;
+import org.eclipse.smila.processing.designer.model.record.*;
 import org.eclipse.wst.wsdl.ExtensibleElement;
 import org.eclipse.wst.wsdl.WSDLElement;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Adapter Factory</b> for the model.
- * It provides an adapter <code>createXXX</code> method for each class of the model.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Adapter Factory</b> for the model. It provides an adapter <code>createXXX</code>
+ * method for each class of the model. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage
  * @generated
  */
-public class ProcessorAdapterFactory extends AdapterFactoryImpl
-{
-    /**
-     * The cached model package.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected static ProcessorPackage modelPackage;
+public class ProcessorAdapterFactory extends AdapterFactoryImpl {
+  /**
+   * The cached model package. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected static ProcessorPackage modelPackage;
 
-    /**
-     * Creates an instance of the adapter factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public ProcessorAdapterFactory()
-    {
-        if (modelPackage == null)
-        {
-            modelPackage = ProcessorPackage.eINSTANCE;
-        }
+  /**
+   * Creates an instance of the adapter factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public ProcessorAdapterFactory() {
+    if (modelPackage == null) {
+      modelPackage = ProcessorPackage.eINSTANCE;
     }
+  }
 
-    /**
-     * Returns whether this factory is applicable for the type of the object.
-     * <!-- begin-user-doc -->
-     * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
-     * <!-- end-user-doc -->
-     * @return whether this factory is applicable for the type of the object.
-     * @generated
-     */
+  /**
+   * Returns whether this factory is applicable for the type of the object. <!-- begin-user-doc --> This implementation
+   * returns <code>true</code> if the object is either the model's package or is an instance object of the model. <!--
+   * end-user-doc -->
+   * 
+   * @return whether this factory is applicable for the type of the object.
+   * @generated
+   */
+  @Override
+  public boolean isFactoryForType(Object object) {
+    if (object == modelPackage) {
+      return true;
+    }
+    if (object instanceof EObject) {
+      return ((EObject) object).eClass().getEPackage() == modelPackage;
+    }
+    return false;
+  }
+
+  /**
+   * The switch that delegates to the <code>createXXX</code> methods. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected ProcessorSwitch<Adapter> modelSwitch = new ProcessorSwitch<Adapter>() {
     @Override
-    public boolean isFactoryForType(Object object)
-    {
-        if (object == modelPackage)
-        {
-            return true;
-        }
-        if (object instanceof EObject)
-        {
-            return ((EObject) object).eClass().getEPackage() == modelPackage;
-        }
-        return false;
+    public Adapter caseInvokePipelet(InvokePipelet object) {
+      return createInvokePipeletAdapter();
     }
 
-    /**
-     * The switch that delegates to the <code>createXXX</code> methods.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected ProcessorSwitch<Adapter> modelSwitch = new ProcessorSwitch<Adapter>()
-    {
-        @Override
-        public Adapter caseInvokePipelet(InvokePipelet object)
-        {
-            return createInvokePipeletAdapter();
-        }
-
-        @Override
-        public Adapter casePipelet(Pipelet object)
-        {
-            return createPipeletAdapter();
-        }
-
-        @Override
-        public Adapter caseVariables(Variables object)
-        {
-            return createVariablesAdapter();
-        }
-
-        @Override
-        public Adapter caseProperty(Property object)
-        {
-            return createPropertyAdapter();
-        }
-
-        @Override
-        public Adapter casePipeletConfiguration(PipeletConfiguration object)
-        {
-            return createPipeletConfigurationAdapter();
-        }
-
-        @Override
-        public Adapter caseInvokeService(InvokeService object)
-        {
-            return createInvokeServiceAdapter();
-        }
-
-        @Override
-        public Adapter caseService(Service object)
-        {
-            return createServiceAdapter();
-        }
-
-        @Override
-        public Adapter caseSetAnnotations(SetAnnotations object)
-        {
-            return createSetAnnotationsAdapter();
-        }
-
-        @Override
-        public Adapter caseWSDLElement(WSDLElement object)
-        {
-            return createWSDLElementAdapter();
-        }
-
-        @Override
-        public Adapter caseIElementExtensible(ElementExtensible object)
-        {
-            return createIElementExtensibleAdapter();
-        }
-
-        @Override
-        public Adapter caseIAttributeExtensible(AttributeExtensible object)
-        {
-            return createIAttributeExtensibleAdapter();
-        }
-
-        @Override
-        public Adapter caseExtensibleElement(ExtensibleElement object)
-        {
-            return createExtensibleElementAdapter();
-        }
-
-        @Override
-        public Adapter caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object)
-        {
-            return createBPEL_ExtensibleElementAdapter();
-        }
-
-        @Override
-        public Adapter caseActivity(Activity object)
-        {
-            return createActivityAdapter();
-        }
-
-        @Override
-        public Adapter caseExtensionActivity(ExtensionActivity object)
-        {
-            return createExtensionActivityAdapter();
-        }
-
-        @Override
-        public Adapter defaultCase(EObject object)
-        {
-            return createEObjectAdapter();
-        }
-    };
-
-    /**
-     * Creates an adapter for the <code>target</code>.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param target the object to adapt.
-     * @return the adapter for the <code>target</code>.
-     * @generated
-     */
     @Override
-    public Adapter createAdapter(Notifier target)
-    {
-        return modelSwitch.doSwitch((EObject) target);
+    public Adapter casePipelet(Pipelet object) {
+      return createPipeletAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet <em>Invoke Pipelet</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet
-     * @generated
-     */
-    public Adapter createInvokePipeletAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseVariables(Variables object) {
+      return createVariablesAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet <em>Pipelet</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.Pipelet
-     * @generated
-     */
-    public Adapter createPipeletAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseConfiguration(Configuration object) {
+      return createConfigurationAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.Variables <em>Variables</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.Variables
-     * @generated
-     */
-    public Adapter createVariablesAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseWSDLElement(WSDLElement object) {
+      return createWSDLElementAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.Property <em>Property</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.Property
-     * @generated
-     */
-    public Adapter createPropertyAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseIElementExtensible(ElementExtensible object) {
+      return createIElementExtensibleAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration <em>Pipelet Configuration</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration
-     * @generated
-     */
-    public Adapter createPipeletConfigurationAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseIAttributeExtensible(AttributeExtensible object) {
+      return createIAttributeExtensibleAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.InvokeService <em>Invoke Service</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.InvokeService
-     * @generated
-     */
-    public Adapter createInvokeServiceAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseExtensibleElement(ExtensibleElement object) {
+      return createExtensibleElementAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.Service <em>Service</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.Service
-     * @generated
-     */
-    public Adapter createServiceAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object) {
+      return createBPEL_ExtensibleElementAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.SetAnnotations <em>Set Annotations</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.processor.SetAnnotations
-     * @generated
-     */
-    public Adapter createSetAnnotationsAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseActivity(Activity object) {
+      return createActivityAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.WSDLElement <em>Element</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.wst.wsdl.WSDLElement
-     * @generated
-     */
-    public Adapter createWSDLElementAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseExtensionActivity(ExtensionActivity object) {
+      return createExtensionActivityAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.ElementExtensible <em>IElement Extensible</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see javax.wsdl.extensions.ElementExtensible
-     * @generated
-     */
-    public Adapter createIElementExtensibleAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseExtensionElement(ExtensionElement object) {
+      return createExtensionElementAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.AttributeExtensible <em>IAttribute Extensible</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see javax.wsdl.extensions.AttributeExtensible
-     * @generated
-     */
-    public Adapter createIAttributeExtensibleAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseRecordAny(RecordAny object) {
+      return createRecordAnyAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.ExtensibleElement <em>Extensible Element</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.wst.wsdl.ExtensibleElement
-     * @generated
-     */
-    public Adapter createExtensibleElementAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseRecordValues(RecordValues object) {
+      return createRecordValuesAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.ExtensibleElement <em>Extensible Element</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.bpel.model.ExtensibleElement
-     * @generated
-     */
-    public Adapter createBPEL_ExtensibleElementAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseRecordMap(RecordMap object) {
+      return createRecordMapAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.Activity <em>Activity</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.bpel.model.Activity
-     * @generated
-     */
-    public Adapter createActivityAdapter()
-    {
-        return null;
+    @Override
+    public Adapter defaultCase(EObject object) {
+      return createEObjectAdapter();
     }
+  };
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.ExtensionActivity <em>Extension Activity</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.bpel.model.ExtensionActivity
-     * @generated
-     */
-    public Adapter createExtensionActivityAdapter()
-    {
-        return null;
-    }
+  /**
+   * Creates an adapter for the <code>target</code>. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param target
+   *          the object to adapt.
+   * @return the adapter for the <code>target</code>.
+   * @generated
+   */
+  @Override
+  public Adapter createAdapter(Notifier target) {
+    return modelSwitch.doSwitch((EObject) target);
+  }
 
-    /**
-     * Creates a new adapter for the default case.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @generated
-     */
-    public Adapter createEObjectAdapter()
-    {
-        return null;
-    }
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet <em>Invoke Pipelet</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.processor.InvokePipelet
+   * @generated
+   */
+  public Adapter createInvokePipeletAdapter() {
+    return null;
+  }
 
-} //ProcessorAdapterFactory
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.processor.Pipelet
+   * <em>Pipelet</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.processor.Pipelet
+   * @generated
+   */
+  public Adapter createPipeletAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.processor.Variables <em>Variables</em>}'. <!-- begin-user-doc
+   * --> This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when
+   * inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.processor.Variables
+   * @generated
+   */
+  public Adapter createVariablesAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.processor.Configuration <em>Configuration</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.processor.Configuration
+   * @generated
+   */
+  public Adapter createConfigurationAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.WSDLElement <em>Element</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.wst.wsdl.WSDLElement
+   * @generated
+   */
+  public Adapter createWSDLElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.ElementExtensible
+   * <em>IElement Extensible</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see javax.wsdl.extensions.ElementExtensible
+   * @generated
+   */
+  public Adapter createIElementExtensibleAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.AttributeExtensible
+   * <em>IAttribute Extensible</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see javax.wsdl.extensions.AttributeExtensible
+   * @generated
+   */
+  public Adapter createIAttributeExtensibleAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.ExtensibleElement
+   * <em>Extensible Element</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.wst.wsdl.ExtensibleElement
+   * @generated
+   */
+  public Adapter createExtensibleElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.ExtensibleElement
+   * <em>Extensible Element</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.bpel.model.ExtensibleElement
+   * @generated
+   */
+  public Adapter createBPEL_ExtensibleElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.Activity <em>Activity</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.bpel.model.Activity
+   * @generated
+   */
+  public Adapter createActivityAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.ExtensionActivity
+   * <em>Extension Activity</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.bpel.model.ExtensionActivity
+   * @generated
+   */
+  public Adapter createExtensionActivityAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.record.ExtensionElement <em>Extension Element</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.ExtensionElement
+   * @generated
+   */
+  public Adapter createExtensionElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.RecordAny
+   * <em>Any</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny
+   * @generated
+   */
+  public Adapter createRecordAnyAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.record.RecordValues <em>Values</em>}'. <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when
+   * inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordValues
+   * @generated
+   */
+  public Adapter createRecordValuesAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.RecordMap
+   * <em>Map</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordMap
+   * @generated
+   */
+  public Adapter createRecordMapAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for the default case. <!-- begin-user-doc --> This default implementation returns null. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @generated
+   */
+  public Adapter createEObjectAdapter() {
+    return null;
+  }
+
+} // ProcessorAdapterFactory
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorConstants.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorConstants.java
index ccfe1b4..33a194c 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorConstants.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorConstants.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
@@ -15,25 +14,29 @@
  * 
  * @author Lars Kunze
  */
-public class ProcessorConstants
-{
-    // Node names
-    public static final String NODE_INVOKE_SERVICE = "invokeService";
-    public static final String NODE_SERVICE = "service";
-    public static final String NODE_VARIABLES = "variables";
-    public static final String NODE_INVOKE_PIPELET = "invokePipelet";
-    public static final String NODE_PIPELET = "pipelet";
-    public static final String NODE_PROPERTY = "Property";
-    public static final String NODE_VALUE = "Value";
-    public static final String NODE_PIPELET_CONFIGURATION = "PipeletConfiguration";
-    public static final String NODE_SET_ANNOTATIONS = "setAnnotations";
+public class ProcessorConstants {
+  // Namespace URI
+  public static final String NS_URI = ProcessorPackage.eINSTANCE.getNsURI();
 
-    // Attribute names
-    public static final String ATT_CLASS = "class";
-    public static final String ATT_INPUT = "input";
-    public static final String ATT_OUTPUT = "output";
-    public static final String ATT_NAME = "name";
+  // Namespace prefix
+  public static final String NS_PREFIX = ProcessorPackage.eINSTANCE.getNsPrefix();
 
-    // Namespace
-    public static final String NS_PREFIX = ProcessorPackage.eINSTANCE.getNsPrefix();
+  // Node names
+  public static final String ELEMENT_VARIABLES = "variables";
+
+  public static final String ELEMENT_INVOKE_PIPELET = "invokePipelet";
+
+  public static final String ELEMENT_PIPELET = "pipelet";
+
+  public static final String ELEMENT_CONFIGURATION = "configuration";
+
+  // Attribute names
+  public static final String ATT_CLASS = "class";
+
+  public static final String ATT_INPUT = "input";
+
+  public static final String ATT_OUTPUT = "output";
+
+  public static final String ATT_NAME = "name";
+
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorSwitch.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorSwitch.java
index c5ae225..20981af 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorSwitch.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorSwitch.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
@@ -16,604 +15,422 @@
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.smila.processing.designer.model.processor.*;
+import org.eclipse.smila.processing.designer.model.record.*;
 import org.eclipse.wst.wsdl.ExtensibleElement;
 import org.eclipse.wst.wsdl.WSDLElement;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Switch</b> for the model's inheritance hierarchy.
- * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
- * to invoke the <code>caseXXX</code> method for each class of the model,
- * starting with the actual class of the object
- * and proceeding up the inheritance hierarchy
- * until a non-null result is returned,
- * which is the result of the switch.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance hierarchy. It supports the call
+ * {@link #doSwitch(EObject) doSwitch(object)} to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the inheritance hierarchy until a non-null result is
+ * returned, which is the result of the switch. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.processor.ProcessorPackage
  * @generated
  */
-public class ProcessorSwitch<T>
-{
-    /**
-     * The cached model package
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected static ProcessorPackage modelPackage;
+public class ProcessorSwitch<T> {
+  /**
+   * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected static ProcessorPackage modelPackage;
 
-    /**
-     * Creates an instance of the switch.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public ProcessorSwitch()
-    {
-        if (modelPackage == null)
-        {
-            modelPackage = ProcessorPackage.eINSTANCE;
+  /**
+   * Creates an instance of the switch. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public ProcessorSwitch() {
+    if (modelPackage == null) {
+      modelPackage = ProcessorPackage.eINSTANCE;
+    }
+  }
+
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  public T doSwitch(EObject theEObject) {
+    return doSwitch(theEObject.eClass(), theEObject);
+  }
+
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  protected T doSwitch(EClass theEClass, EObject theEObject) {
+    if (theEClass.eContainer() == modelPackage) {
+      return doSwitch(theEClass.getClassifierID(), theEObject);
+    } else {
+      List<EClass> eSuperTypes = theEClass.getESuperTypes();
+      return eSuperTypes.isEmpty() ? defaultCase(theEObject) : doSwitch(eSuperTypes.get(0), theEObject);
+    }
+  }
+
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  protected T doSwitch(int classifierID, EObject theEObject) {
+    switch (classifierID) {
+      case ProcessorPackage.INVOKE_PIPELET: {
+        InvokePipelet invokePipelet = (InvokePipelet) theEObject;
+        T result = caseInvokePipelet(invokePipelet);
+        if (result == null) {
+          result = caseExtensionActivity(invokePipelet);
         }
-    }
-
-    /**
-     * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-     * @generated
-     */
-    public T doSwitch(EObject theEObject)
-    {
-        return doSwitch(theEObject.eClass(), theEObject);
-    }
-
-    /**
-     * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-     * @generated
-     */
-    protected T doSwitch(EClass theEClass, EObject theEObject)
-    {
-        if (theEClass.eContainer() == modelPackage)
-        {
-            return doSwitch(theEClass.getClassifierID(), theEObject);
+        if (result == null) {
+          result = caseExtensionElement(invokePipelet);
         }
-        else
-        {
-            List<EClass> eSuperTypes = theEClass.getESuperTypes();
-            return eSuperTypes.isEmpty() ? defaultCase(theEObject) : doSwitch(eSuperTypes.get(0), theEObject);
+        if (result == null) {
+          result = caseActivity(invokePipelet);
         }
-    }
-
-    /**
-     * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-     * @generated
-     */
-    protected T doSwitch(int classifierID, EObject theEObject)
-    {
-        switch (classifierID)
-        {
-            case ProcessorPackage.INVOKE_PIPELET :
-            {
-                InvokePipelet invokePipelet = (InvokePipelet) theEObject;
-                T result = caseInvokePipelet(invokePipelet);
-                if (result == null)
-                {
-                    result = caseExtensionActivity(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = caseActivity(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(invokePipelet);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.PIPELET :
-            {
-                Pipelet pipelet = (Pipelet) theEObject;
-                T result = casePipelet(pipelet);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(pipelet);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(pipelet);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(pipelet);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(pipelet);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(pipelet);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.VARIABLES :
-            {
-                Variables variables = (Variables) theEObject;
-                T result = caseVariables(variables);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(variables);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(variables);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(variables);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(variables);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(variables);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.PROPERTY :
-            {
-                Property property = (Property) theEObject;
-                T result = caseProperty(property);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(property);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(property);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(property);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(property);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(property);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.PIPELET_CONFIGURATION :
-            {
-                PipeletConfiguration pipeletConfiguration = (PipeletConfiguration) theEObject;
-                T result = casePipeletConfiguration(pipeletConfiguration);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(pipeletConfiguration);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(pipeletConfiguration);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(pipeletConfiguration);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(pipeletConfiguration);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(pipeletConfiguration);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.INVOKE_SERVICE :
-            {
-                InvokeService invokeService = (InvokeService) theEObject;
-                T result = caseInvokeService(invokeService);
-                if (result == null)
-                {
-                    result = caseExtensionActivity(invokeService);
-                }
-                if (result == null)
-                {
-                    result = caseActivity(invokeService);
-                }
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(invokeService);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(invokeService);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(invokeService);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(invokeService);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(invokeService);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.SERVICE :
-            {
-                Service service = (Service) theEObject;
-                T result = caseService(service);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(service);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(service);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(service);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(service);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(service);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case ProcessorPackage.SET_ANNOTATIONS :
-            {
-                SetAnnotations setAnnotations = (SetAnnotations) theEObject;
-                T result = caseSetAnnotations(setAnnotations);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(setAnnotations);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(setAnnotations);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(setAnnotations);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(setAnnotations);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(setAnnotations);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            default :
-                return defaultCase(theEObject);
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(invokePipelet);
         }
+        if (result == null) {
+          result = caseExtensibleElement(invokePipelet);
+        }
+        if (result == null) {
+          result = caseWSDLElement(invokePipelet);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(invokePipelet);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(invokePipelet);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case ProcessorPackage.PIPELET: {
+        Pipelet pipelet = (Pipelet) theEObject;
+        T result = casePipelet(pipelet);
+        if (result == null) {
+          result = caseExtensionElement(pipelet);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(pipelet);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(pipelet);
+        }
+        if (result == null) {
+          result = caseWSDLElement(pipelet);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(pipelet);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(pipelet);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case ProcessorPackage.VARIABLES: {
+        Variables variables = (Variables) theEObject;
+        T result = caseVariables(variables);
+        if (result == null) {
+          result = caseExtensionElement(variables);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(variables);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(variables);
+        }
+        if (result == null) {
+          result = caseWSDLElement(variables);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(variables);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(variables);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case ProcessorPackage.CONFIGURATION: {
+        Configuration configuration = (Configuration) theEObject;
+        T result = caseConfiguration(configuration);
+        if (result == null) {
+          result = caseRecordMap(configuration);
+        }
+        if (result == null) {
+          result = caseRecordValues(configuration);
+        }
+        if (result == null) {
+          result = caseRecordAny(configuration);
+        }
+        if (result == null) {
+          result = caseExtensionElement(configuration);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(configuration);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(configuration);
+        }
+        if (result == null) {
+          result = caseWSDLElement(configuration);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(configuration);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(configuration);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      default:
+        return defaultCase(theEObject);
     }
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Invoke Pipelet</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Invoke Pipelet</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseInvokePipelet(InvokePipelet object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Invoke Pipelet</em>'. <!-- begin-user-doc -->
+   * This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Invoke Pipelet</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseInvokePipelet(InvokePipelet object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Pipelet</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Pipelet</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T casePipelet(Pipelet object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Pipelet</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Pipelet</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePipelet(Pipelet object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Variables</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Variables</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseVariables(Variables object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Variables</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Variables</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseVariables(Variables object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Property</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Property</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseProperty(Property object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Configuration</em>'. <!-- begin-user-doc -->
+   * This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Configuration</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseConfiguration(Configuration object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Pipelet Configuration</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Pipelet Configuration</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T casePipeletConfiguration(PipeletConfiguration object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Element</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseWSDLElement(WSDLElement object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Invoke Service</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Invoke Service</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseInvokeService(InvokeService object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>IElement Extensible</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>IElement Extensible</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIElementExtensible(ElementExtensible object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Service</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Service</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseService(Service object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'. <!--
+   * begin-user-doc --> This implementation returns null; returning a non-null result will terminate the switch. <!--
+   * end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIAttributeExtensible(AttributeExtensible object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Set Annotations</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Set Annotations</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseSetAnnotations(SetAnnotations object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseExtensibleElement(ExtensibleElement object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Element</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Element</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseWSDLElement(WSDLElement object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>IElement Extensible</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>IElement Extensible</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseIElementExtensible(ElementExtensible object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Activity</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Activity</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseActivity(Activity object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseIAttributeExtensible(AttributeExtensible object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extension Activity</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extension Activity</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseExtensionActivity(ExtensionActivity object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseExtensibleElement(ExtensibleElement object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extension Element</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extension Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseExtensionElement(ExtensionElement object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Any</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Any</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordAny(RecordAny object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Activity</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Activity</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseActivity(Activity object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Values</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Values</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordValues(RecordValues object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Extension Activity</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Extension Activity</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseExtensionActivity(ExtensionActivity object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Map</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Map</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordMap(RecordMap object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch, but this is the last case anyway.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject)
-     * @generated
-     */
-    public T defaultCase(EObject object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>EObject</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch, but this is the last case
+   * anyway. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+   * @generated
+   */
+  public T defaultCase(EObject object) {
+    return null;
+  }
 
-} //ProcessorSwitch
+} // ProcessorSwitch
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorUtils.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorUtils.java
index ed247ef..58e9414 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorUtils.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/processor/util/ProcessorUtils.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.processor.util;
 
@@ -18,22 +17,20 @@
  * 
  * @author Lars Kunze
  */
-public class ProcessorUtils
-{
-    /**
-     * Adds the SMILA namespace to the given process
-     * @param process
-     * @return the preferred namespace prefix
-     */
-    public static String addNamespace(Process process)
-    {
-        String nsPrefix = ProcessorPackage.eINSTANCE.getNsPrefix();
-        if (process != null)
-        { // FIXME: Workaround for jUnit tests
-            String nsURI = ProcessorPackage.eINSTANCE.getNsURI();
-            INamespaceMap<String, String> nsMap = BPELUtils.getNamespaceMap(process);
-            nsMap.put(nsPrefix, nsURI);
-        }
-        return nsPrefix;
+public class ProcessorUtils {
+  /**
+   * Adds the SMILA namespace to the given process
+   * 
+   * @param process
+   * @return the preferred namespace prefix
+   */
+  public static String addNamespace(Process process) {
+    String nsPrefix = ProcessorPackage.eINSTANCE.getNsPrefix();
+    if (process != null) { // FIXME: Workaround for jUnit tests
+      String nsURI = ProcessorConstants.NS_URI;
+      INamespaceMap<String, String> nsMap = BPELUtils.getNamespaceMap(process);
+      nsMap.put(nsPrefix, nsURI);
     }
+    return nsPrefix;
+  }
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/Annotation.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/Annotation.java
deleted file mode 100644
index 9639af9..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/Annotation.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.record;
-
-import org.eclipse.bpel.model.ExtensibleElement;
-import org.eclipse.emf.common.util.EList;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Annotation</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.Annotation#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.Annotation#getAnnotationValues <em>Annotation Values</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.Annotation#getAnnotations <em>Annotations</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotation()
- * @model
- * @generated
- */
-public interface Annotation extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Name</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Name</em>' attribute.
-     * @see #setName(String)
-     * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotation_Name()
-     * @model required="true"
-     * @generated
-     */
-    String getName();
-
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.record.Annotation#getName <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Name</em>' attribute.
-     * @see #getName()
-     * @generated
-     */
-    void setName(String value);
-
-    /**
-     * Returns the value of the '<em><b>Annotation Values</b></em>' containment reference list.
-     * The list contents are of type {@link org.eclipse.smila.processing.designer.model.record.AnnotationValue}.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Annotation Values</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Annotation Values</em>' containment reference list.
-     * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotation_AnnotationValues()
-     * @model containment="true"
-     * @generated
-     */
-    EList<AnnotationValue> getAnnotationValues();
-
-    /**
-     * Returns the value of the '<em><b>Annotations</b></em>' containment reference list.
-     * The list contents are of type {@link org.eclipse.smila.processing.designer.model.record.Annotation}.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Annotations</em>' reference list isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Annotations</em>' containment reference list.
-     * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotation_Annotations()
-     * @model containment="true"
-     * @generated
-     */
-    EList<Annotation> getAnnotations();
-
-} // Annotation
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/AnnotationValue.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/AnnotationValue.java
deleted file mode 100644
index b52e3db..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/AnnotationValue.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.record;
-
-import org.eclipse.bpel.model.ExtensibleElement;
-
-/**
- * <!-- begin-user-doc -->
- * A representation of the model object '<em><b>Annotation Value</b></em>'.
- * <!-- end-user-doc -->
- *
- * <p>
- * The following features are supported:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue#getValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotationValue()
- * @model
- * @generated
- */
-public interface AnnotationValue extends ExtensibleElement
-{
-    /**
-     * Returns the value of the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Name</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Name</em>' attribute.
-     * @see #setName(String)
-     * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotationValue_Name()
-     * @model required="true"
-     * @generated
-     */
-    String getName();
-
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue#getName <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Name</em>' attribute.
-     * @see #getName()
-     * @generated
-     */
-    void setName(String value);
-
-    /**
-     * Returns the value of the '<em><b>Value</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <p>
-     * If the meaning of the '<em>Value</em>' attribute isn't clear,
-     * there really should be more of a description here...
-     * </p>
-     * <!-- end-user-doc -->
-     * @return the value of the '<em>Value</em>' attribute.
-     * @see #setValue(String)
-     * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getAnnotationValue_Value()
-     * @model
-     * @generated
-     */
-    String getValue();
-
-    /**
-     * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue#getValue <em>Value</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param value the new value of the '<em>Value</em>' attribute.
-     * @see #getValue()
-     * @generated
-     */
-    void setValue(String value);
-
-} // AnnotationValue
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/ExtensionElement.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/ExtensionElement.java
new file mode 100644
index 0000000..473006f
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/ExtensionElement.java
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record;
+
+import org.eclipse.bpel.model.ExtensibleElement;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Extension Element</b></em>'. <!-- end-user-doc
+ * -->
+ * 
+ * 
+ * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getExtensionElement()
+ * @model interface="true" abstract="true"
+ * @generated
+ */
+public interface ExtensionElement extends ExtensibleElement {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @model dataType="org.eclipse.wst.wsdl.DOMElement" documentDataType="org.eclipse.wst.wsdl.DOMDocument"
+   * @generated
+   */
+  Element fixElement(Document document);
+
+} // ExtensionElement
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordAny.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordAny.java
new file mode 100644
index 0000000..5df8d00
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordAny.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Any</b></em>'. <!-- end-user-doc -->
+ * 
+ * <p>
+ * The following features are supported:
+ * <ul>
+ * <li>{@link org.eclipse.smila.processing.designer.model.record.RecordAny#getKey <em>Key</em>}</li>
+ * </ul>
+ * </p>
+ * 
+ * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordAny()
+ * @model abstract="true"
+ * @generated
+ */
+public interface RecordAny extends ExtensionElement {
+  /**
+   * Returns the value of the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Key</em>' attribute isn't clear, there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Key</em>' attribute.
+   * @see #setKey(String)
+   * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordAny_Key()
+   * @model
+   * @generated
+   */
+  String getKey();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.record.RecordAny#getKey <em>Key</em>}'
+   * attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Key</em>' attribute.
+   * @see #getKey()
+   * @generated
+   */
+  void setKey(String value);
+
+  /**
+   * Indicates that this object is a map.
+   * 
+   * @return {@code true} if this object is an instance of {@link RecordMap}
+   */
+  public boolean isMap();
+
+  /**
+   * Indicates that this object is a sequence.
+   * 
+   * @return {@code true} if this object is an instance of {@link RecordSeq}
+   */
+  public boolean isSeq();
+
+  /**
+   * Indicates that this object is a (simple) value.
+   * 
+   * @return {@code true} if this object is an instance of {@link RecordVal}
+   */
+  public boolean isVal();
+} // RecordAny
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordFactory.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordFactory.java
index f1fd50c..31bd711 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordFactory.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordFactory.java
@@ -1,56 +1,57 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record;
 
 import org.eclipse.emf.ecore.EFactory;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Factory</b> for the model.
- * It provides a create method for each non-abstract class of the model.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Factory</b> for the model. It provides a create method for each non-abstract class of
+ * the model. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.record.RecordPackage
  * @generated
  */
-public interface RecordFactory extends EFactory
-{
-    /**
-     * The singleton instance of the factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    RecordFactory eINSTANCE = org.eclipse.smila.processing.designer.model.record.impl.RecordFactoryImpl.init();
+public interface RecordFactory extends EFactory {
+  /**
+   * The singleton instance of the factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  RecordFactory eINSTANCE = org.eclipse.smila.processing.designer.model.record.impl.RecordFactoryImpl.init();
 
-    /**
-     * Returns a new object of class '<em>Annotation</em>'.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return a new object of class '<em>Annotation</em>'.
-     * @generated
-     */
-    Annotation createAnnotation();
+  /**
+   * Returns a new object of class '<em>Map</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Map</em>'.
+   * @generated
+   */
+  RecordMap createRecordMap();
 
-    /**
-     * Returns a new object of class '<em>Annotation Value</em>'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return a new object of class '<em>Annotation Value</em>'.
-     * @generated
-     */
-    AnnotationValue createAnnotationValue();
+  /**
+   * Returns a new object of class '<em>Seq</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Seq</em>'.
+   * @generated
+   */
+  RecordSeq createRecordSeq();
 
-    /**
-     * Returns the package supported by this factory.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the package supported by this factory.
-     * @generated
-     */
-    RecordPackage getRecordPackage();
+  /**
+   * Returns a new object of class '<em>Val</em>'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return a new object of class '<em>Val</em>'.
+   * @generated
+   */
+  RecordVal createRecordVal();
 
-} //RecordFactory
+  /**
+   * Returns the package supported by this factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the package supported by this factory.
+   * @generated
+   */
+  RecordPackage getRecordPackage();
+
+} // RecordFactory
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordMap.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordMap.java
new file mode 100644
index 0000000..4c9e36b
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordMap.java
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Map</b></em>'. <!-- end-user-doc -->
+ * 
+ * 
+ * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordMap()
+ * @model
+ * @generated
+ */
+public interface RecordMap extends RecordValues {
+
+} // RecordMap
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordPackage.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordPackage.java
index c11be4a..37d059e 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordPackage.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordPackage.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record;
 
@@ -10,367 +9,644 @@
 import org.eclipse.emf.ecore.*;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Package</b> for the model.
- * It contains accessors for the meta objects to represent
+ * <!-- begin-user-doc --> The <b>Package</b> for the model. It contains accessors for the meta objects to represent
  * <ul>
- *   <li>each class,</li>
- *   <li>each feature of each class,</li>
- *   <li>each enum,</li>
- *   <li>and each data type</li>
+ * <li>each class,</li>
+ * <li>each feature of each class,</li>
+ * <li>each enum,</li>
+ * <li>and each data type</li>
  * </ul>
  * <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.record.RecordFactory
  * @model kind="package"
  * @generated
  */
-public interface RecordPackage extends EPackage
-{
+public interface RecordPackage extends EPackage {
+  /**
+   * The package name. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  String eNAME = "record";
+
+  /**
+   * The package namespace URI. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  String eNS_URI = "http://www.eclipse.org/smila/record";
+
+  /**
+   * The package namespace name. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  String eNS_PREFIX = "rec";
+
+  /**
+   * The singleton instance of the package. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  RecordPackage eINSTANCE = org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl.init();
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.ExtensionElementImpl
+   * <em>Extension Element</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.record.impl.ExtensionElementImpl
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getExtensionElement()
+   * @generated
+   */
+  int EXTENSION_ELEMENT = 4;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int EXTENSION_ELEMENT__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int EXTENSION_ELEMENT__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int EXTENSION_ELEMENT__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int EXTENSION_ELEMENT__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
+
+  /**
+   * The number of structural features of the '<em>Extension Element</em>' class. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int EXTENSION_ELEMENT_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordAnyImpl
+   * <em>Any</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordAnyImpl
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordAny()
+   * @generated
+   */
+  int RECORD_ANY = 3;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_ANY__DOCUMENTATION_ELEMENT = EXTENSION_ELEMENT__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_ANY__ELEMENT = EXTENSION_ELEMENT__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_ANY__EEXTENSIBILITY_ELEMENTS = EXTENSION_ELEMENT__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_ANY__DOCUMENTATION = EXTENSION_ELEMENT__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_ANY__KEY = EXTENSION_ELEMENT_FEATURE_COUNT + 0;
+
+  /**
+   * The number of structural features of the '<em>Any</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_ANY_FEATURE_COUNT = EXTENSION_ELEMENT_FEATURE_COUNT + 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordValuesImpl
+   * <em>Values</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordValuesImpl
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordValues()
+   * @generated
+   */
+  int RECORD_VALUES = 5;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES__DOCUMENTATION_ELEMENT = RECORD_ANY__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES__ELEMENT = RECORD_ANY__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES__EEXTENSIBILITY_ELEMENTS = RECORD_ANY__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES__DOCUMENTATION = RECORD_ANY__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES__KEY = RECORD_ANY__KEY;
+
+  /**
+   * The feature id for the '<em><b>Values</b></em>' containment reference list. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES__VALUES = RECORD_ANY_FEATURE_COUNT + 0;
+
+  /**
+   * The number of structural features of the '<em>Values</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VALUES_FEATURE_COUNT = RECORD_ANY_FEATURE_COUNT + 1;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordMapImpl
+   * <em>Map</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordMapImpl
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordMap()
+   * @generated
+   */
+  int RECORD_MAP = 0;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP__DOCUMENTATION_ELEMENT = RECORD_VALUES__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP__ELEMENT = RECORD_VALUES__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP__EEXTENSIBILITY_ELEMENTS = RECORD_VALUES__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP__DOCUMENTATION = RECORD_VALUES__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP__KEY = RECORD_VALUES__KEY;
+
+  /**
+   * The feature id for the '<em><b>Values</b></em>' containment reference list. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP__VALUES = RECORD_VALUES__VALUES;
+
+  /**
+   * The number of structural features of the '<em>Map</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_MAP_FEATURE_COUNT = RECORD_VALUES_FEATURE_COUNT + 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordSeqImpl
+   * <em>Seq</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordSeqImpl
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordSeq()
+   * @generated
+   */
+  int RECORD_SEQ = 1;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ__DOCUMENTATION_ELEMENT = RECORD_VALUES__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ__ELEMENT = RECORD_VALUES__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ__EEXTENSIBILITY_ELEMENTS = RECORD_VALUES__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ__DOCUMENTATION = RECORD_VALUES__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ__KEY = RECORD_VALUES__KEY;
+
+  /**
+   * The feature id for the '<em><b>Values</b></em>' containment reference list. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ__VALUES = RECORD_VALUES__VALUES;
+
+  /**
+   * The number of structural features of the '<em>Seq</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_SEQ_FEATURE_COUNT = RECORD_VALUES_FEATURE_COUNT + 0;
+
+  /**
+   * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordValImpl
+   * <em>Val</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordValImpl
+   * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordVal()
+   * @generated
+   */
+  int RECORD_VAL = 2;
+
+  /**
+   * The feature id for the '<em><b>Documentation Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL__DOCUMENTATION_ELEMENT = RECORD_ANY__DOCUMENTATION_ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>Element</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL__ELEMENT = RECORD_ANY__ELEMENT;
+
+  /**
+   * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL__EEXTENSIBILITY_ELEMENTS = RECORD_ANY__EEXTENSIBILITY_ELEMENTS;
+
+  /**
+   * The feature id for the '<em><b>Documentation</b></em>' containment reference. <!-- begin-user-doc --> <!--
+   * end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL__DOCUMENTATION = RECORD_ANY__DOCUMENTATION;
+
+  /**
+   * The feature id for the '<em><b>Key</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL__KEY = RECORD_ANY__KEY;
+
+  /**
+   * The feature id for the '<em><b>Value</b></em>' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL__VALUE = RECORD_ANY_FEATURE_COUNT + 0;
+
+  /**
+   * The number of structural features of the '<em>Val</em>' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   * @ordered
+   */
+  int RECORD_VAL_FEATURE_COUNT = RECORD_ANY_FEATURE_COUNT + 1;
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.RecordMap
+   * <em>Map</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Map</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordMap
+   * @generated
+   */
+  EClass getRecordMap();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.RecordSeq
+   * <em>Seq</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Seq</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordSeq
+   * @generated
+   */
+  EClass getRecordSeq();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.RecordVal
+   * <em>Val</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Val</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordVal
+   * @generated
+   */
+  EClass getRecordVal();
+
+  /**
+   * Returns the meta object for the attribute '
+   * {@link org.eclipse.smila.processing.designer.model.record.RecordVal#getValue <em>Value</em>}'. <!-- begin-user-doc
+   * --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the attribute '<em>Value</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordVal#getValue()
+   * @see #getRecordVal()
+   * @generated
+   */
+  EAttribute getRecordVal_Value();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.RecordAny
+   * <em>Any</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Any</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny
+   * @generated
+   */
+  EClass getRecordAny();
+
+  /**
+   * Returns the meta object for the attribute '
+   * {@link org.eclipse.smila.processing.designer.model.record.RecordAny#getKey <em>Key</em>}'. <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * 
+   * @return the meta object for the attribute '<em>Key</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#getKey()
+   * @see #getRecordAny()
+   * @generated
+   */
+  EAttribute getRecordAny_Key();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.ExtensionElement
+   * <em>Extension Element</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Extension Element</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.ExtensionElement
+   * @generated
+   */
+  EClass getExtensionElement();
+
+  /**
+   * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.RecordValues
+   * <em>Values</em>}'. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for class '<em>Values</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordValues
+   * @generated
+   */
+  EClass getRecordValues();
+
+  /**
+   * Returns the meta object for the containment reference list '
+   * {@link org.eclipse.smila.processing.designer.model.record.RecordValues#getValues <em>Values</em>}'. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the meta object for the containment reference list '<em>Values</em>'.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordValues#getValues()
+   * @see #getRecordValues()
+   * @generated
+   */
+  EReference getRecordValues_Values();
+
+  /**
+   * Returns the factory that creates the instances of the model. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the factory that creates the instances of the model.
+   * @generated
+   */
+  RecordFactory getRecordFactory();
+
+  /**
+   * <!-- begin-user-doc --> Defines literals for the meta objects that represent
+   * <ul>
+   * <li>each class,</li>
+   * <li>each feature of each class,</li>
+   * <li>each enum,</li>
+   * <li>and each data type</li>
+   * </ul>
+   * <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  interface Literals {
     /**
-     * The package name.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordMapImpl
+     * <em>Map</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordMapImpl
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordMap()
      * @generated
      */
-    String eNAME = "record";
+    EClass RECORD_MAP = eINSTANCE.getRecordMap();
 
     /**
-     * The package namespace URI.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordSeqImpl
+     * <em>Seq</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordSeqImpl
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordSeq()
      * @generated
      */
-    String eNS_URI = "http://www.eclipse.org/smila/record";
+    EClass RECORD_SEQ = eINSTANCE.getRecordSeq();
 
     /**
-     * The package namespace name.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordValImpl
+     * <em>Val</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordValImpl
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordVal()
      * @generated
      */
-    String eNS_PREFIX = "rec";
+    EClass RECORD_VAL = eINSTANCE.getRecordVal();
 
     /**
-     * The singleton instance of the package.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Value</b></em>' attribute feature. <!-- begin-user-doc --> <!--
+     * end-user-doc -->
+     * 
      * @generated
      */
-    RecordPackage eINSTANCE = org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl.init();
+    EAttribute RECORD_VAL__VALUE = eINSTANCE.getRecordVal_Value();
 
     /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl <em>Annotation</em>}' class.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl
-     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getAnnotation()
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordAnyImpl
+     * <em>Any</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordAnyImpl
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordAny()
      * @generated
      */
-    int ANNOTATION = 0;
+    EClass RECORD_ANY = eINSTANCE.getRecordAny();
 
     /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
+     * The meta object literal for the '<em><b>Key</b></em>' attribute feature. <!-- begin-user-doc --> <!--
+     * end-user-doc -->
+     * 
      * @generated
-     * @ordered
      */
-    int ANNOTATION__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
+    EAttribute RECORD_ANY__KEY = eINSTANCE.getRecordAny_Key();
 
     /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
+     * The meta object literal for the '
+     * {@link org.eclipse.smila.processing.designer.model.record.impl.ExtensionElementImpl <em>Extension Element</em>}'
+     * class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.record.impl.ExtensionElementImpl
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getExtensionElement()
      * @generated
-     * @ordered
      */
-    int ANNOTATION__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
+    EClass EXTENSION_ELEMENT = eINSTANCE.getExtensionElement();
 
     /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
+     * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.RecordValuesImpl
+     * <em>Values</em>}' class. <!-- begin-user-doc --> <!-- end-user-doc -->
+     * 
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordValuesImpl
+     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getRecordValues()
      * @generated
-     * @ordered
      */
-    int ANNOTATION__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
+    EClass RECORD_VALUES = eINSTANCE.getRecordValues();
 
     /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION__NAME = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The feature id for the '<em><b>Annotation Values</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION__ANNOTATION_VALUES = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The feature id for the '<em><b>Annotations</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION__ANNOTATIONS = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 2;
-
-    /**
-     * The number of structural features of the '<em>Annotation</em>' class.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 3;
-
-    /**
-     * The meta object id for the '{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationValueImpl <em>Annotation Value</em>}' class.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @see org.eclipse.smila.processing.designer.model.record.impl.AnnotationValueImpl
-     * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getAnnotationValue()
+     * The meta object literal for the '<em><b>Values</b></em>' containment reference list feature. <!-- begin-user-doc
+     * --> <!-- end-user-doc -->
+     * 
      * @generated
      */
-    int ANNOTATION_VALUE = 1;
+    EReference RECORD_VALUES__VALUES = eINSTANCE.getRecordValues_Values();
 
-    /**
-     * The feature id for the '<em><b>Documentation Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE__DOCUMENTATION_ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION_ELEMENT;
+  }
 
-    /**
-     * The feature id for the '<em><b>Element</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE__ELEMENT = BPELPackage.EXTENSIBLE_ELEMENT__ELEMENT;
-
-    /**
-     * The feature id for the '<em><b>EExtensibility Elements</b></em>' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE__EEXTENSIBILITY_ELEMENTS = BPELPackage.EXTENSIBLE_ELEMENT__EEXTENSIBILITY_ELEMENTS;
-
-    /**
-     * The feature id for the '<em><b>Documentation</b></em>' containment reference.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE__DOCUMENTATION = BPELPackage.EXTENSIBLE_ELEMENT__DOCUMENTATION;
-
-    /**
-     * The feature id for the '<em><b>Name</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE__NAME = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 0;
-
-    /**
-     * The feature id for the '<em><b>Value</b></em>' attribute.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE__VALUE = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 1;
-
-    /**
-     * The number of structural features of the '<em>Annotation Value</em>' class.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     * @ordered
-     */
-    int ANNOTATION_VALUE_FEATURE_COUNT = BPELPackage.EXTENSIBLE_ELEMENT_FEATURE_COUNT + 2;
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.Annotation <em>Annotation</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Annotation</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.Annotation
-     * @generated
-     */
-    EClass getAnnotation();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.record.Annotation#getName <em>Name</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Name</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.Annotation#getName()
-     * @see #getAnnotation()
-     * @generated
-     */
-    EAttribute getAnnotation_Name();
-
-    /**
-     * Returns the meta object for the containment reference list '{@link org.eclipse.smila.processing.designer.model.record.Annotation#getAnnotationValues <em>Annotation Values</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for the containment reference list '<em>Annotation Values</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.Annotation#getAnnotationValues()
-     * @see #getAnnotation()
-     * @generated
-     */
-    EReference getAnnotation_AnnotationValues();
-
-    /**
-     * Returns the meta object for the containment reference list '{@link org.eclipse.smila.processing.designer.model.record.Annotation#getAnnotations <em>Annotations</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for the containment reference list '<em>Annotations</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.Annotation#getAnnotations()
-     * @see #getAnnotation()
-     * @generated
-     */
-    EReference getAnnotation_Annotations();
-
-    /**
-     * Returns the meta object for class '{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue <em>Annotation Value</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for class '<em>Annotation Value</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.AnnotationValue
-     * @generated
-     */
-    EClass getAnnotationValue();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue#getName <em>Name</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Name</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.AnnotationValue#getName()
-     * @see #getAnnotationValue()
-     * @generated
-     */
-    EAttribute getAnnotationValue_Name();
-
-    /**
-     * Returns the meta object for the attribute '{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue#getValue <em>Value</em>}'.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the meta object for the attribute '<em>Value</em>'.
-     * @see org.eclipse.smila.processing.designer.model.record.AnnotationValue#getValue()
-     * @see #getAnnotationValue()
-     * @generated
-     */
-    EAttribute getAnnotationValue_Value();
-
-    /**
-     * Returns the factory that creates the instances of the model.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @return the factory that creates the instances of the model.
-     * @generated
-     */
-    RecordFactory getRecordFactory();
-
-    /**
-     * <!-- begin-user-doc -->
-     * Defines literals for the meta objects that represent
-     * <ul>
-     *   <li>each class,</li>
-     *   <li>each feature of each class,</li>
-     *   <li>each enum,</li>
-     *   <li>and each data type</li>
-     * </ul>
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    interface Literals
-    {
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl <em>Annotation</em>}' class.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl
-         * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getAnnotation()
-         * @generated
-         */
-        EClass ANNOTATION = eINSTANCE.getAnnotation();
-
-        /**
-         * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-        * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute ANNOTATION__NAME = eINSTANCE.getAnnotation_Name();
-
-        /**
-         * The meta object literal for the '<em><b>Annotation Values</b></em>' containment reference list feature.
-         * <!-- begin-user-doc -->
-        * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference ANNOTATION__ANNOTATION_VALUES = eINSTANCE.getAnnotation_AnnotationValues();
-
-        /**
-         * The meta object literal for the '<em><b>Annotations</b></em>' containment reference list feature.
-         * <!-- begin-user-doc -->
-        * <!-- end-user-doc -->
-         * @generated
-         */
-        EReference ANNOTATION__ANNOTATIONS = eINSTANCE.getAnnotation_Annotations();
-
-        /**
-         * The meta object literal for the '{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationValueImpl <em>Annotation Value</em>}' class.
-         * <!-- begin-user-doc -->
-        * <!-- end-user-doc -->
-         * @see org.eclipse.smila.processing.designer.model.record.impl.AnnotationValueImpl
-         * @see org.eclipse.smila.processing.designer.model.record.impl.RecordPackageImpl#getAnnotationValue()
-         * @generated
-         */
-        EClass ANNOTATION_VALUE = eINSTANCE.getAnnotationValue();
-
-        /**
-         * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-        * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute ANNOTATION_VALUE__NAME = eINSTANCE.getAnnotationValue_Name();
-
-        /**
-         * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
-         * <!-- begin-user-doc -->
-        * <!-- end-user-doc -->
-         * @generated
-         */
-        EAttribute ANNOTATION_VALUE__VALUE = eINSTANCE.getAnnotationValue_Value();
-
-    }
-
-} //RecordPackage
+} // RecordPackage
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordSeq.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordSeq.java
new file mode 100644
index 0000000..2a50718
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordSeq.java
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Seq</b></em>'. <!-- end-user-doc -->
+ * 
+ * 
+ * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordSeq()
+ * @model
+ * @generated
+ */
+public interface RecordSeq extends RecordValues {
+
+} // RecordSeq
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordVal.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordVal.java
new file mode 100644
index 0000000..26ead1f
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordVal.java
@@ -0,0 +1,188 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record;
+
+import java.text.*;
+import java.util.Date;
+import java.util.Locale;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Val</b></em>'. <!-- end-user-doc -->
+ * 
+ * <p>
+ * The following features are supported:
+ * <ul>
+ * <li>{@link org.eclipse.smila.processing.designer.model.record.RecordVal#getValue <em>Value</em>}</li>
+ * </ul>
+ * </p>
+ * 
+ * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordVal()
+ * @model
+ * @generated
+ */
+public interface RecordVal extends RecordAny {
+
+  /**
+   * Enumeration with the possible value types.
+   */
+  public enum Type {
+    /** The string type */
+    STRING(String.class) {
+      @Override
+      public Object parse(String text) throws ParseException {
+        return text;
+      }
+    },
+    /** The integer type */
+    LONG(Long.class) {
+      @Override
+      public Object parse(String text) throws ParseException {
+        try {
+          return Long.parseLong(text);
+        } catch (NumberFormatException e) {
+          throw new ParseException(e.toString(), 0);
+        }
+      }
+    },
+    /** The float type */
+    DOUBLE(Double.class) {
+      @Override
+      public Object parse(String text) throws ParseException {
+        try {
+          return Double.parseDouble(text);
+        } catch (NumberFormatException e) {
+          throw new ParseException(e.toString(), 0);
+        }
+      }
+    },
+    /** The boolean type */
+    BOOLEAN(Boolean.class) {
+      @Override
+      public Object parse(String text) throws ParseException {
+        // TODO: Check for "true" and "false" only?
+        return "true".equals(text);
+      }
+    },
+    /** The date type */
+    DATE(java.sql.Date.class) {
+      DateFormat format = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
+
+      @Override
+      public String format(Object o) {
+        return format.format(o);
+      }
+
+      @Override
+      public Object parse(String text) throws ParseException {
+        return new java.sql.Date(format.parse(text).getTime());
+      }
+    },
+    /** The timestamp type */
+    DATETIME(java.sql.Timestamp.class) {
+      DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.ENGLISH);
+
+      @Override
+      public String format(Object o) {
+        return format.format(o);
+      }
+
+      @Override
+      public Object parse(String text) throws ParseException {
+        return new java.sql.Timestamp(format.parse(text).getTime());
+      }
+
+    };
+
+    /**
+     * Resolves the type of the given value.
+     * 
+     * @param value
+     *          the value
+     * @return the type or {@code null} if not a known type
+     */
+    public static Type getType(Object value) {
+      for (Type type : values()) {
+        if (type.instanceClass.isInstance(value)) {
+          return type;
+        }
+      }
+      if (value instanceof Date) {
+        return DATETIME;
+      } else if (value instanceof Float) {
+        return DOUBLE;
+      } else if (value instanceof Number) {
+        return LONG;
+      } else if (value instanceof CharSequence) {
+        return STRING;
+      }
+      return null;
+    }
+
+    public final Class<?> instanceClass;
+
+    private Type(Class<?> instanceClass) {
+      this.instanceClass = instanceClass;
+    }
+
+    /**
+     * Formats the given object.
+     * 
+     * @param o
+     *          the object to format
+     * @return the string representation of the given object.
+     * @throws IllegalArgumentException
+     *           if the given object has the wrong type
+     */
+    public String format(Object o) {
+      return String.valueOf(o);
+    }
+
+    /**
+     * Parses an object of the current type from the given string.
+     * 
+     * @param text
+     *          the text to parse
+     * @return the parsed object
+     * @throws ParseException
+     *           if the given text has the wrong format
+     */
+    public abstract Object parse(String text) throws ParseException;
+  }
+
+  /**
+   * Returns the value of the '<em><b>Value</b></em>' attribute. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Value</em>' attribute isn't clear, there really should be more of a description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Value</em>' attribute.
+   * @see #setValue(Object)
+   * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordVal_Value()
+   * @model unique="false"
+   * @generated
+   */
+  Object getValue();
+
+  /**
+   * Sets the value of the '{@link org.eclipse.smila.processing.designer.model.record.RecordVal#getValue <em>Value</em>}
+   * ' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param value
+   *          the new value of the '<em>Value</em>' attribute.
+   * @see #getValue()
+   * @generated
+   */
+  void setValue(Object value);
+
+  /**
+   * Resolves the current type of the value.
+   * 
+   * @return the current type of the value
+   */
+  public Type getType();
+
+} // RecordVal
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordValues.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordValues.java
new file mode 100644
index 0000000..0d8b9f0
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/RecordValues.java
@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record;
+
+import org.eclipse.emf.common.util.EList;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>Values</b></em>'. <!-- end-user-doc -->
+ * 
+ * <p>
+ * The following features are supported:
+ * <ul>
+ * <li>{@link org.eclipse.smila.processing.designer.model.record.RecordValues#getValues <em>Values</em>}</li>
+ * </ul>
+ * </p>
+ * 
+ * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordValues()
+ * @model abstract="true"
+ * @generated
+ */
+public interface RecordValues extends RecordAny {
+  /**
+   * Returns the value of the '<em><b>Values</b></em>' containment reference list. The list contents are of type
+   * {@link org.eclipse.smila.processing.designer.model.record.RecordAny}. <!-- begin-user-doc -->
+   * <p>
+   * If the meaning of the '<em>Values</em>' containment reference list isn't clear, there really should be more of a
+   * description here...
+   * </p>
+   * <!-- end-user-doc -->
+   * 
+   * @return the value of the '<em>Values</em>' containment reference list.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#getRecordValues_Values()
+   * @model containment="true"
+   * @generated
+   */
+  EList<RecordAny> getValues();
+
+} // RecordValues
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/AnnotationImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/AnnotationImpl.java
deleted file mode 100644
index 7856004..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/AnnotationImpl.java
+++ /dev/null
@@ -1,407 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.record.impl;
-
-import java.util.Collection;
-import java.util.List;
-
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.common.notify.NotificationChain;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.*;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.emf.ecore.util.EObjectContainmentEList;
-import org.eclipse.emf.ecore.util.InternalEList;
-import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
-import org.eclipse.smila.processing.designer.model.record.*;
-import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
-import org.w3c.dom.Element;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Annotation</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl#getAnnotationValues <em>Annotation Values</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationImpl#getAnnotations <em>Annotations</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class AnnotationImpl extends ExtensibleElementImpl implements Annotation
-{
-    /**
-     * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected static final String NAME_EDEFAULT = null;
-
-    /**
-     * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected String name = NAME_EDEFAULT;
-
-    /**
-     * The cached value of the '{@link #getAnnotationValues() <em>Annotation Values</em>}' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getAnnotationValues()
-     * @generated
-     * @ordered
-     */
-    protected EList<AnnotationValue> annotationValues;
-
-    /**
-     * The cached value of the '{@link #getAnnotations() <em>Annotations</em>}' containment reference list.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getAnnotations()
-     * @generated
-     * @ordered
-     */
-    protected EList<Annotation> annotations;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected AnnotationImpl()
-    {
-        super();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return RecordPackage.Literals.ANNOTATION;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getName()
-    {
-        return name;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setName(String newName)
-    {
-        String oldName = name;
-        name = newName;
-
-        if (!isReconciling())
-        {
-            ReconciliationHelper.replaceAttribute(this, RecordConstants.ATT_N, newName);
-        }
-
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, RecordPackage.ANNOTATION__NAME, oldName, name));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EList<AnnotationValue> getAnnotationValues()
-    {
-        if (annotationValues == null)
-        {
-            annotationValues =
-                    new EObjectContainmentEList<AnnotationValue>(AnnotationValue.class, this,
-                            RecordPackage.ANNOTATION__ANNOTATION_VALUES);
-        }
-        return annotationValues;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EList<Annotation> getAnnotations()
-    {
-        if (annotations == null)
-        {
-            annotations =
-                    new EObjectContainmentEList<Annotation>(Annotation.class, this, RecordPackage.ANNOTATION__ANNOTATIONS);
-        }
-        return annotations;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION__ANNOTATION_VALUES :
-                return ((InternalEList<?>) getAnnotationValues()).basicRemove(otherEnd, msgs);
-            case RecordPackage.ANNOTATION__ANNOTATIONS :
-                return ((InternalEList<?>) getAnnotations()).basicRemove(otherEnd, msgs);
-        }
-        return super.eInverseRemove(otherEnd, featureID, msgs);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION__NAME :
-                return getName();
-            case RecordPackage.ANNOTATION__ANNOTATION_VALUES :
-                return getAnnotationValues();
-            case RecordPackage.ANNOTATION__ANNOTATIONS :
-                return getAnnotations();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @SuppressWarnings("unchecked")
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION__NAME :
-                setName((String) newValue);
-                return;
-            case RecordPackage.ANNOTATION__ANNOTATION_VALUES :
-                getAnnotationValues().clear();
-                getAnnotationValues().addAll((Collection<? extends AnnotationValue>) newValue);
-                return;
-            case RecordPackage.ANNOTATION__ANNOTATIONS :
-                getAnnotations().clear();
-                getAnnotations().addAll((Collection<? extends Annotation>) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION__NAME :
-                setName(NAME_EDEFAULT);
-                return;
-            case RecordPackage.ANNOTATION__ANNOTATION_VALUES :
-                getAnnotationValues().clear();
-                return;
-            case RecordPackage.ANNOTATION__ANNOTATIONS :
-                getAnnotations().clear();
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION__NAME :
-                return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-            case RecordPackage.ANNOTATION__ANNOTATION_VALUES :
-                return annotationValues != null && !annotationValues.isEmpty();
-            case RecordPackage.ANNOTATION__ANNOTATIONS :
-                return annotations != null && !annotations.isEmpty();
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String toString()
-    {
-        if (eIsProxy())
-        {
-            return super.toString();
-        }
-
-        StringBuffer result = new StringBuffer(super.toString());
-        result.append(" (name: ");
-        result.append(name);
-        result.append(')');
-        return result.toString();
-    }
-
-    /**
-     * Adopt any new annotation / annotation value.
-     * 
-     * @see org.eclipse.wst.wsdl.internal.impl.WSDLElementImpl#adoptContent
-     */
-    @Override
-    protected void adoptContent(EReference eReference, Object newValue)
-    {
-        boolean isAnnoatation = newValue instanceof Annotation;
-        if (isAnnoatation || newValue instanceof AnnotationValue)
-        {
-            boolean oldUpdatingDom = super.isUpdatingDOM();
-            if (!ReconciliationHelper.isLoading(this) && getElement() != null)
-            {
-                try
-                {
-                    setUpdatingDOM(true);
-                    Element parentElement = getElement();
-                    if (isAnnoatation)
-                    {
-                        Annotation annotation = (Annotation) newValue;
-                        Element annotationElement = annotation.getElement();
-                        if (annotationElement == null)
-                        {
-                            annotationElement =
-                                    parentElement.getOwnerDocument().createElementNS(RecordPackage.eNS_URI,
-                                            RecordConstants.NODE_AN);
-                            annotation.setElement(annotationElement);
-                            annotationElement.setPrefix(RecordPackage.eNS_PREFIX);
-                            if (annotation.getName() != null)
-                            {
-                                annotationElement.setAttribute(RecordConstants.ATT_N, annotation.getName());
-                            }
-                        }
-                        if (annotationElement.getParentNode() != parentElement)
-                        {
-                            int index = annotations.indexOf(annotation);
-                            List<Element> elements =
-                                    DOMUtils.getChildElements(parentElement, RecordPackage.eNS_URI, RecordConstants.NODE_AN);
-                            Element next;
-                            if (index >= elements.size())
-                            {
-                                // Insert element after the last AN element (before any other)
-                                if (elements.size() == 0)
-                                {
-                                    next = DOMUtils.getNextElement(parentElement.getFirstChild());
-                                }
-                                else
-                                {
-                                    next = DOMUtils.getNextElement(elements.get(elements.size() - 1).getNextSibling());
-                                }
-                            }
-                            else
-                            {
-                                next = elements.get(index);
-                            }
-                            DOMUtils.insertIndented(parentElement, annotationElement, next);
-                        }
-                    }
-                    else
-                    {
-                        AnnotationValue value = (AnnotationValue) newValue;
-                        Element element = value.getElement();
-                        if (element == null)
-                        {
-                            element =
-                                    parentElement.getOwnerDocument().createElementNS(RecordPackage.eNS_URI,
-                                            RecordConstants.NODE_V);
-                            value.setElement(element);
-                            element.setPrefix(RecordPackage.eNS_PREFIX);
-                            if (value.getValue() != null)
-                            {
-                                DOMUtils.writeTextContent(element, value.getValue());
-                            }
-                        }
-                        if (element.getParentNode() != parentElement)
-                        {
-                            int index = annotationValues.indexOf(value);
-                            List<Element> elements =
-                                    DOMUtils.getChildElements(parentElement, RecordPackage.eNS_URI, RecordConstants.NODE_V);
-                            DOMUtils.insertIndented(parentElement, element,
-                                    index >= elements.size() ? null : elements.get(index));
-                        }
-                    }
-                }
-                finally
-                {
-                    setUpdatingDOM(oldUpdatingDom);
-                }
-            }
-        }
-        else
-        {
-            super.adoptContent(eReference, newValue);
-        }
-    }
-
-    @Override
-    protected void orphanContent(EReference eReference, Object obj)
-    {
-        if (obj instanceof Annotation && !isReconciling())
-        {
-            ReconciliationHelper.orphanChild(this, (Annotation) obj);
-        }
-        if (obj instanceof AnnotationValue && !isReconciling())
-        {
-            ReconciliationHelper.orphanChild(this, (AnnotationValue) obj);
-        }
-        super.orphanContent(eReference, obj);
-    }
-} //AnnotationImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/AnnotationValueImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/AnnotationValueImpl.java
deleted file mode 100644
index ba24270..0000000
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/AnnotationValueImpl.java
+++ /dev/null
@@ -1,291 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.model.record.impl;
-
-import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
-import org.eclipse.bpel.model.util.ReconciliationHelper;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.impl.ENotificationImpl;
-import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
-import org.eclipse.smila.processing.designer.model.record.AnnotationValue;
-import org.eclipse.smila.processing.designer.model.record.RecordPackage;
-import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
-import org.w3c.dom.Element;
-
-/**
- * <!-- begin-user-doc -->
- * An implementation of the model object '<em><b>Annotation Value</b></em>'.
- * <!-- end-user-doc -->
- * <p>
- * The following features are implemented:
- * <ul>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationValueImpl#getName <em>Name</em>}</li>
- *   <li>{@link org.eclipse.smila.processing.designer.model.record.impl.AnnotationValueImpl#getValue <em>Value</em>}</li>
- * </ul>
- * </p>
- *
- * @generated
- */
-public class AnnotationValueImpl extends ExtensibleElementImpl implements AnnotationValue
-{
-    /**
-     * The default value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected static final String NAME_EDEFAULT = null;
-
-    /**
-     * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getName()
-     * @generated
-     * @ordered
-     */
-    protected String name = NAME_EDEFAULT;
-
-    /**
-     * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getValue()
-     * @generated
-     * @ordered
-     */
-    protected static final String VALUE_EDEFAULT = null;
-
-    /**
-     * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #getValue()
-     * @generated
-     * @ordered
-     */
-    protected String value = VALUE_EDEFAULT;
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected AnnotationValueImpl()
-    {
-        super();
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    protected EClass eStaticClass()
-    {
-        return RecordPackage.Literals.ANNOTATION_VALUE;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getName()
-    {
-        return name;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setName(String newName)
-    {
-        String oldName = name;
-        if (!isReconciling)
-        {
-            ReconciliationHelper.replaceAttribute(this, RecordConstants.ATT_N, newName);
-        }
-        name = newName;
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, RecordPackage.ANNOTATION_VALUE__NAME, oldName, name));
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String getValue()
-    {
-        return value;
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @customized
-     */
-    @Override
-    public void setValue(String newValue)
-    {
-        String oldValue = value;
-        if (!isReconciling)
-        {
-            replaceValue(newValue);
-        }
-        value = newValue;
-        if (eNotificationRequired())
-        {
-            eNotify(new ENotificationImpl(this, Notification.SET, RecordPackage.ANNOTATION_VALUE__VALUE, oldValue, value));
-        }
-    }
-
-    /**
-     * Replaces the value at the linked element.
-     * 
-     * Can't use {@link ReconciliationHelper#replaceText} as this is using CDATA sections.
-     *
-     * @param newValue the new value
-     */
-    private void replaceValue(String newValue)
-    {
-        if (ReconciliationHelper.isLoading(this))
-        {
-            return;
-        }
-
-        boolean oldUpdatingDom = isUpdatingDOM();
-        try
-        {
-            setUpdatingDOM(true);
-
-            Element element = getElement();
-            if (element == null)
-            {
-                System.err.println("trying to replace text on null element");
-                return;
-            }
-
-            DOMUtils.writeTextContent(element, newValue);
-        }
-        finally
-        {
-            setUpdatingDOM(oldUpdatingDom);
-        }
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Object eGet(int featureID, boolean resolve, boolean coreType)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION_VALUE__NAME :
-                return getName();
-            case RecordPackage.ANNOTATION_VALUE__VALUE :
-                return getValue();
-        }
-        return super.eGet(featureID, resolve, coreType);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eSet(int featureID, Object newValue)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION_VALUE__NAME :
-                setName((String) newValue);
-                return;
-            case RecordPackage.ANNOTATION_VALUE__VALUE :
-                setValue((String) newValue);
-                return;
-        }
-        super.eSet(featureID, newValue);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public void eUnset(int featureID)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION_VALUE__NAME :
-                setName(NAME_EDEFAULT);
-                return;
-            case RecordPackage.ANNOTATION_VALUE__VALUE :
-                setValue(VALUE_EDEFAULT);
-                return;
-        }
-        super.eUnset(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public boolean eIsSet(int featureID)
-    {
-        switch (featureID)
-        {
-            case RecordPackage.ANNOTATION_VALUE__NAME :
-                return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
-            case RecordPackage.ANNOTATION_VALUE__VALUE :
-                return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
-        }
-        return super.eIsSet(featureID);
-    }
-
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public String toString()
-    {
-        if (eIsProxy())
-        {
-            return super.toString();
-        }
-
-        StringBuffer result = new StringBuffer(super.toString());
-        result.append(" (name: ");
-        result.append(name);
-        result.append(", value: ");
-        result.append(value);
-        result.append(')');
-        return result.toString();
-    }
-
-} //AnnotationValueImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/ExtensionElementImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/ExtensionElementImpl.java
new file mode 100644
index 0000000..1358f09
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/ExtensionElementImpl.java
@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record.impl;
+
+import org.eclipse.bpel.model.impl.ExtensibleElementImpl;
+import org.eclipse.bpel.model.impl.ExtensionActivityImpl;
+import org.eclipse.bpel.model.util.ReconciliationHelper;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.smila.processing.designer.model.record.ExtensionElement;
+import org.eclipse.smila.processing.designer.model.record.RecordPackage;
+import org.eclipse.wst.wsdl.WSDLElement;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Extension Element</b></em>'. <!-- end-user-doc
+ * -->
+ * <p>
+ * </p>
+ * 
+ * @generated
+ */
+public abstract class ExtensionElementImpl extends ExtensibleElementImpl implements ExtensionElement {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected ExtensionElementImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return RecordPackage.Literals.EXTENSION_ELEMENT;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public Element fixElement(Document document) {
+    if (getElement() == null && !isUpdatingDOM()) {
+      try {
+        setUpdatingDOM(true);
+        setElement(createFixedElement(document));
+      } finally {
+        setUpdatingDOM(false);
+      }
+    }
+    return getElement();
+  }
+
+  protected abstract Element createFixedElement(Document document);
+
+  protected <E extends ExtensionElement> void replaceChild(E oldElement, E newElement) {
+    if (shouldReconcile()) {
+      if (newElement.fixElement(getElement().getOwnerDocument()) != null) {
+        ReconciliationHelper.replaceChild(this, oldElement, newElement);
+      }
+    }
+  }
+
+  protected boolean shouldReconcile() {
+    return !isReconciling() && !isUpdatingDOM() && getElement() != null && !ReconciliationHelper.isLoading(this);
+  }
+
+  /**
+   * @see org.eclipse.bpel.model.impl.ExtensibleElementImpl#setUpdatingDOM(boolean)
+   */
+  @Override
+  public void setUpdatingDOM(boolean updatingDOM) {
+    super.setUpdatingDOM(updatingDOM);
+    // Adjust extension activity
+    WSDLElement container = getContainer();
+    while (container != null) {
+      if (container instanceof ExtensionActivityImpl) {
+        ((ExtensionActivityImpl) container).setUpdatingDOM(updatingDOM);
+        return;
+      }
+      container = container.getContainer();
+    }
+  }
+
+} // ExtensionElementImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordAnyImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordAnyImpl.java
new file mode 100644
index 0000000..bdbfc06
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordAnyImpl.java
@@ -0,0 +1,194 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record.impl;
+
+import org.eclipse.bpel.model.util.ReconciliationHelper;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.smila.processing.designer.model.record.RecordAny;
+import org.eclipse.smila.processing.designer.model.record.RecordPackage;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Any</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ * <li>{@link org.eclipse.smila.processing.designer.model.record.impl.RecordAnyImpl#getKey <em>Key</em>}</li>
+ * </ul>
+ * </p>
+ * 
+ * @generated
+ */
+public abstract class RecordAnyImpl extends ExtensionElementImpl implements RecordAny {
+  /**
+   * The default value of the '{@link #getKey() <em>Key</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see #getKey()
+   * @generated
+   * @ordered
+   */
+  protected static final String KEY_EDEFAULT = null;
+
+  /**
+   * The cached value of the '{@link #getKey() <em>Key</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see #getKey()
+   * @generated
+   * @ordered
+   */
+  protected String key = KEY_EDEFAULT;
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected RecordAnyImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return RecordPackage.Literals.RECORD_ANY;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String getKey() {
+    return key;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public void setKey(String newKey) {
+    String oldKey = key;
+    key = newKey;
+
+    if (shouldReconcile()) {
+      ReconciliationHelper.replaceAttribute(this, RecordConstants.ATT_KEY, newKey);
+    }
+
+    if (eNotificationRequired()) {
+      eNotify(new ENotificationImpl(this, Notification.SET, RecordPackage.RECORD_ANY__KEY, oldKey, key));
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+      case RecordPackage.RECORD_ANY__KEY:
+        return getKey();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue) {
+    switch (featureID) {
+      case RecordPackage.RECORD_ANY__KEY:
+        setKey((String) newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+      case RecordPackage.RECORD_ANY__KEY:
+        setKey(KEY_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+      case RecordPackage.RECORD_ANY__KEY:
+        return KEY_EDEFAULT == null ? key != null : !KEY_EDEFAULT.equals(key);
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String toString() {
+    if (eIsProxy()) {
+      return super.toString();
+    }
+
+    StringBuffer result = new StringBuffer(super.toString());
+    result.append(" (key: ");
+    result.append(key);
+    result.append(')');
+    return result.toString();
+  }
+
+  /**
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#isMap()
+   */
+  @Override
+  public boolean isMap() {
+    return false;
+  }
+
+  /**
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#isSeq()
+   */
+  @Override
+  public boolean isSeq() {
+    return false;
+  }
+
+  /**
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#isVal()
+   */
+  @Override
+  public boolean isVal() {
+    return false;
+  }
+
+} // RecordAnyImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordFactoryImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordFactoryImpl.java
index 28ec036..33fe197 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordFactoryImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordFactoryImpl.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record.impl;
 
@@ -12,112 +11,109 @@
 import org.eclipse.smila.processing.designer.model.record.*;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Factory</b>.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model <b>Factory</b>. <!-- end-user-doc -->
+ * 
  * @generated
  */
-public class RecordFactoryImpl extends EFactoryImpl implements RecordFactory
-{
-    /**
-     * Creates the default factory implementation.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public static RecordFactory init()
-    {
-        try
-        {
-            RecordFactory theRecordFactory =
-                    (RecordFactory) EPackage.Registry.INSTANCE.getEFactory("http://www.eclipse.org/smila/record");
-            if (theRecordFactory != null)
-            {
-                return theRecordFactory;
-            }
-        }
-        catch (Exception exception)
-        {
-            EcorePlugin.INSTANCE.log(exception);
-        }
-        return new RecordFactoryImpl();
+public class RecordFactoryImpl extends EFactoryImpl implements RecordFactory {
+  /**
+   * Creates the default factory implementation. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public static RecordFactory init() {
+    try {
+      RecordFactory theRecordFactory =
+        (RecordFactory) EPackage.Registry.INSTANCE.getEFactory("http://www.eclipse.org/smila/record");
+      if (theRecordFactory != null) {
+        return theRecordFactory;
+      }
+    } catch (Exception exception) {
+      EcorePlugin.INSTANCE.log(exception);
     }
+    return new RecordFactoryImpl();
+  }
 
-    /**
-     * Creates an instance of the factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public RecordFactoryImpl()
-    {
-        super();
+  /**
+   * Creates an instance of the factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public RecordFactoryImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EObject create(EClass eClass) {
+    switch (eClass.getClassifierID()) {
+      case RecordPackage.RECORD_MAP:
+        return createRecordMap();
+      case RecordPackage.RECORD_SEQ:
+        return createRecordSeq();
+      case RecordPackage.RECORD_VAL:
+        return createRecordVal();
+      default:
+        throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
     }
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EObject create(EClass eClass)
-    {
-        switch (eClass.getClassifierID())
-        {
-            case RecordPackage.ANNOTATION :
-                return createAnnotation();
-            case RecordPackage.ANNOTATION_VALUE :
-                return createAnnotationValue();
-            default :
-                throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
-        }
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public RecordMap createRecordMap() {
+    RecordMapImpl recordMap = new RecordMapImpl();
+    return recordMap;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public Annotation createAnnotation()
-    {
-        AnnotationImpl annotation = new AnnotationImpl();
-        return annotation;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public RecordSeq createRecordSeq() {
+    RecordSeqImpl recordSeq = new RecordSeqImpl();
+    return recordSeq;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public AnnotationValue createAnnotationValue()
-    {
-        AnnotationValueImpl annotationValue = new AnnotationValueImpl();
-        return annotationValue;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public RecordVal createRecordVal() {
+    RecordValImpl recordVal = new RecordValImpl();
+    return recordVal;
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public RecordPackage getRecordPackage()
-    {
-        return (RecordPackage) getEPackage();
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public RecordPackage getRecordPackage() {
+    return (RecordPackage) getEPackage();
+  }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @deprecated
-     * @generated
-     */
-    @Deprecated
-    public static RecordPackage getPackage()
-    {
-        return RecordPackage.eINSTANCE;
-    }
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @deprecated
+   * @generated
+   */
+  @Deprecated
+  public static RecordPackage getPackage() {
+    return RecordPackage.eINSTANCE;
+  }
 
-} //RecordFactoryImpl
+} // RecordFactoryImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordMapImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordMapImpl.java
new file mode 100644
index 0000000..3f1a47d
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordMapImpl.java
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.smila.processing.designer.model.record.RecordMap;
+import org.eclipse.smila.processing.designer.model.record.RecordPackage;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Map</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * </p>
+ * 
+ * @generated
+ */
+public class RecordMapImpl extends RecordValuesImpl implements RecordMap {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected RecordMapImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return RecordPackage.Literals.RECORD_MAP;
+  }
+
+  /**
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#isMap()
+   */
+  @Override
+  public boolean isMap() {
+    return true;
+  }
+
+  /**
+   * @see ExtensionElementImpl#createFixedElement(Document)
+   */
+  @Override
+  protected Element createFixedElement(Document document) {
+    Element element = document.createElementNS(RecordConstants.NS_URI, RecordConstants.ELEMENT_MAP);
+    element.setPrefix(RecordConstants.NS_PREFIX);
+    return createFixedElement(document, element);
+  }
+
+} // RecordMapImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordPackageImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordPackageImpl.java
index 5ceee51..38398cc 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordPackageImpl.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordPackageImpl.java
@@ -1,311 +1,352 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record.impl;
 
-import javax.xml.namespace.QName;
-
 import org.eclipse.bpel.model.BPELPackage;
-import org.eclipse.bpel.model.extensions.BPELExtensionRegistry;
 import org.eclipse.bpel.model.messageproperties.MessagepropertiesPackage;
 import org.eclipse.bpel.model.partnerlinktype.PartnerlinktypePackage;
 import org.eclipse.emf.ecore.*;
 import org.eclipse.emf.ecore.impl.EPackageImpl;
-import org.eclipse.smila.processing.designer.model.processor.InvokeService;
 import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
-import org.eclipse.smila.processing.designer.model.processor.util.*;
+import org.eclipse.smila.processing.designer.model.processor.impl.ProcessorPackageImpl;
 import org.eclipse.smila.processing.designer.model.record.*;
+import org.eclipse.wst.wsdl.WSDLPackage;
 
 /**
- * <!-- begin-user-doc -->
- * An implementation of the model <b>Package</b>.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> An implementation of the model <b>Package</b>. <!-- end-user-doc -->
+ * 
  * @generated
  */
-public class RecordPackageImpl extends EPackageImpl implements RecordPackage
-{
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass annotationEClass = null;
+public class RecordPackageImpl extends EPackageImpl implements RecordPackage {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass recordMapEClass = null;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private EClass annotationValueEClass = null;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass recordSeqEClass = null;
 
-    /**
-     * Creates an instance of the model <b>Package</b>, registered with
-     * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
-     * package URI value.
-     * <p>Note: the correct way to create the package is via the static
-     * factory method {@link #init init()}, which also performs
-     * initialization of the package, or returns the registered package,
-     * if one already exists.
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @see org.eclipse.emf.ecore.EPackage.Registry
-     * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#eNS_URI
-     * @see #init()
-     * @generated
-     */
-    private RecordPackageImpl()
-    {
-        super(eNS_URI, RecordFactory.eINSTANCE);
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass recordValEClass = null;
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass recordAnyEClass = null;
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass extensionElementEClass = null;
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private EClass recordValuesEClass = null;
+
+  /**
+   * Creates an instance of the model <b>Package</b>, registered with {@link org.eclipse.emf.ecore.EPackage.Registry
+   * EPackage.Registry} by the package package URI value.
+   * <p>
+   * Note: the correct way to create the package is via the static factory method {@link #init init()}, which also
+   * performs initialization of the package, or returns the registered package, if one already exists. <!--
+   * begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @see org.eclipse.emf.ecore.EPackage.Registry
+   * @see org.eclipse.smila.processing.designer.model.record.RecordPackage#eNS_URI
+   * @see #init()
+   * @generated
+   */
+  private RecordPackageImpl() {
+    super(eNS_URI, RecordFactory.eINSTANCE);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private static boolean isInited = false;
+
+  /**
+   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+   * 
+   * <p>
+   * This method is used to initialize {@link RecordPackage#eINSTANCE} when that field is accessed. Clients should not
+   * invoke it directly. Instead, they should simply access that field to obtain the package. <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * 
+   * @see #eNS_URI
+   * @see #createPackageContents()
+   * @see #initializePackageContents()
+   * @generated
+   */
+  public static RecordPackage init() {
+    if (isInited) {
+      return (RecordPackage) EPackage.Registry.INSTANCE.getEPackage(RecordPackage.eNS_URI);
     }
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private static boolean isInited = false;
+    // Obtain or create and register package
+    RecordPackageImpl theRecordPackage =
+      (RecordPackageImpl) (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof RecordPackageImpl ? EPackage.Registry.INSTANCE
+        .get(eNS_URI) : new RecordPackageImpl());
 
-    /**
-     * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
-     * 
-     * <p>This method is used to initialize {@link RecordPackage#eINSTANCE} when that field is accessed.
-     * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @see #eNS_URI
-     * @see #createPackageContents()
-     * @see #initializePackageContents()
-     * @generated
-     */
-    public static RecordPackage init()
-    {
-        if (isInited)
-        {
-            return (RecordPackage) EPackage.Registry.INSTANCE.getEPackage(RecordPackage.eNS_URI);
-        }
+    isInited = true;
 
-        // Obtain or create and register package
-        RecordPackageImpl theRecordPackage =
-                (RecordPackageImpl) (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof RecordPackageImpl
-                        ? EPackage.Registry.INSTANCE.get(eNS_URI) : new RecordPackageImpl());
+    // Initialize simple dependencies
+    BPELPackage.eINSTANCE.eClass();
+    PartnerlinktypePackage.eINSTANCE.eClass();
+    MessagepropertiesPackage.eINSTANCE.eClass();
 
-        isInited = true;
+    // Obtain or create and register interdependencies
+    ProcessorPackageImpl theProcessorPackage =
+      (ProcessorPackageImpl) (EPackage.Registry.INSTANCE.getEPackage(ProcessorPackage.eNS_URI) instanceof ProcessorPackageImpl ? EPackage.Registry.INSTANCE
+        .getEPackage(ProcessorPackage.eNS_URI) : ProcessorPackage.eINSTANCE);
 
-        // Initialize simple dependencies
-        BPELPackage.eINSTANCE.eClass();
-        PartnerlinktypePackage.eINSTANCE.eClass();
-        MessagepropertiesPackage.eINSTANCE.eClass();
+    // Create package meta-data objects
+    theRecordPackage.createPackageContents();
+    theProcessorPackage.createPackageContents();
 
-        // Create package meta-data objects
-        theRecordPackage.createPackageContents();
+    // Initialize created meta-data
+    theRecordPackage.initializePackageContents();
+    theProcessorPackage.initializePackageContents();
 
-        // Initialize created meta-data
-        theRecordPackage.initializePackageContents();
+    // Mark meta-data to indicate it can't be changed
+    theRecordPackage.freeze();
 
-        // Mark meta-data to indicate it can't be changed
-        theRecordPackage.freeze();
+    // Update the registry and return the package
+    EPackage.Registry.INSTANCE.put(RecordPackage.eNS_URI, theRecordPackage);
+    return theRecordPackage;
+  }
 
-        // Update the registry and return the package
-        EPackage.Registry.INSTANCE.put(RecordPackage.eNS_URI, theRecordPackage);
-        return theRecordPackage;
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getRecordMap() {
+    return recordMapEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getRecordSeq() {
+    return recordSeqEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getRecordVal() {
+    return recordValEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EAttribute getRecordVal_Value() {
+    return (EAttribute) recordValEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getRecordAny() {
+    return recordAnyEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EAttribute getRecordAny_Key() {
+    return (EAttribute) recordAnyEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getExtensionElement() {
+    return extensionElementEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EClass getRecordValues() {
+    return recordValuesEClass;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EReference getRecordValues_Values() {
+    return (EReference) recordValuesEClass.getEStructuralFeatures().get(0);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public RecordFactory getRecordFactory() {
+    return (RecordFactory) getEFactoryInstance();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private boolean isCreated = false;
+
+  /**
+   * Creates the meta-model objects for the package. This method is guarded to have no affect on any invocation but its
+   * first. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public void createPackageContents() {
+    if (isCreated) {
+      return;
     }
+    isCreated = true;
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getAnnotation()
-    {
-        return annotationEClass;
+    // Create classes and their features
+    recordMapEClass = createEClass(RECORD_MAP);
+
+    recordSeqEClass = createEClass(RECORD_SEQ);
+
+    recordValEClass = createEClass(RECORD_VAL);
+    createEAttribute(recordValEClass, RECORD_VAL__VALUE);
+
+    recordAnyEClass = createEClass(RECORD_ANY);
+    createEAttribute(recordAnyEClass, RECORD_ANY__KEY);
+
+    extensionElementEClass = createEClass(EXTENSION_ELEMENT);
+
+    recordValuesEClass = createEClass(RECORD_VALUES);
+    createEReference(recordValuesEClass, RECORD_VALUES__VALUES);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  private boolean isInitialized = false;
+
+  /**
+   * Complete the initialization of the package and its meta-model. This method is guarded to have no affect on any
+   * invocation but its first. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public void initializePackageContents() {
+    if (isInitialized) {
+      return;
     }
+    isInitialized = true;
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getAnnotation_Name()
-    {
-        return (EAttribute) annotationEClass.getEStructuralFeatures().get(0);
-    }
+    // Initialize package
+    setName(eNAME);
+    setNsPrefix(eNS_PREFIX);
+    setNsURI(eNS_URI);
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getAnnotation_AnnotationValues()
-    {
-        return (EReference) annotationEClass.getEStructuralFeatures().get(1);
-    }
+    // Obtain other dependent packages
+    BPELPackage theBPELPackage = (BPELPackage) EPackage.Registry.INSTANCE.getEPackage(BPELPackage.eNS_URI);
+    WSDLPackage theWSDLPackage = (WSDLPackage) EPackage.Registry.INSTANCE.getEPackage(WSDLPackage.eNS_URI);
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EReference getAnnotation_Annotations()
-    {
-        return (EReference) annotationEClass.getEStructuralFeatures().get(2);
-    }
+    // Create type parameters
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EClass getAnnotationValue()
-    {
-        return annotationValueEClass;
-    }
+    // Set bounds for type parameters
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getAnnotationValue_Name()
-    {
-        return (EAttribute) annotationValueEClass.getEStructuralFeatures().get(0);
-    }
+    // Add supertypes to classes
+    recordMapEClass.getESuperTypes().add(this.getRecordValues());
+    recordSeqEClass.getESuperTypes().add(this.getRecordValues());
+    recordValEClass.getESuperTypes().add(this.getRecordAny());
+    recordAnyEClass.getESuperTypes().add(this.getExtensionElement());
+    extensionElementEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
+    recordValuesEClass.getESuperTypes().add(this.getRecordAny());
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public EAttribute getAnnotationValue_Value()
-    {
-        return (EAttribute) annotationValueEClass.getEStructuralFeatures().get(1);
-    }
+    // Initialize classes and features; add operations and parameters
+    initEClass(recordMapEClass, RecordMap.class, "RecordMap", !IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
 
-    /**
-     * <!-- begin-user-doc -->
-    * <!-- end-user-doc -->
-     * @generated
-     */
-    @Override
-    public RecordFactory getRecordFactory()
-    {
-        return (RecordFactory) getEFactoryInstance();
-    }
+    initEClass(recordSeqEClass, RecordSeq.class, "RecordSeq", !IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private boolean isCreated = false;
+    initEClass(recordValEClass, RecordVal.class, "RecordVal", !IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getRecordVal_Value(), ecorePackage.getEJavaObject(), "value", null, 0, 1, RecordVal.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
-    /**
-     * Creates the meta-model objects for the package.  This method is
-     * guarded to have no affect on any invocation but its first.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public void createPackageContents()
-    {
-        if (isCreated)
-        {
-            return;
-        }
-        isCreated = true;
+    initEClass(recordAnyEClass, RecordAny.class, "RecordAny", IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getRecordAny_Key(), ecorePackage.getEString(), "key", null, 0, 1, RecordAny.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 
-        // Create classes and their features
-        annotationEClass = createEClass(ANNOTATION);
-        createEAttribute(annotationEClass, ANNOTATION__NAME);
-        createEReference(annotationEClass, ANNOTATION__ANNOTATION_VALUES);
-        createEReference(annotationEClass, ANNOTATION__ANNOTATIONS);
+    initEClass(extensionElementEClass, ExtensionElement.class, "ExtensionElement", IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
 
-        annotationValueEClass = createEClass(ANNOTATION_VALUE);
-        createEAttribute(annotationValueEClass, ANNOTATION_VALUE__NAME);
-        createEAttribute(annotationValueEClass, ANNOTATION_VALUE__VALUE);
-    }
+    EOperation op =
+      addEOperation(extensionElementEClass, theWSDLPackage.getDOMElement(), "fixElement", 0, 1, IS_UNIQUE,
+        IS_ORDERED);
+    addEParameter(op, theWSDLPackage.getDOMDocument(), "document", 0, 1, IS_UNIQUE, IS_ORDERED);
 
-    /**
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    private boolean isInitialized = false;
+    initEClass(recordValuesEClass, RecordValues.class, "RecordValues", IS_ABSTRACT, !IS_INTERFACE,
+      IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getRecordValues_Values(), this.getRecordAny(), null, "values", null, 0, -1, RecordValues.class,
+      !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
+      !IS_DERIVED, IS_ORDERED);
 
-    /**
-     * Complete the initialization of the package and its meta-model.  This
-     * method is guarded to have no affect on any invocation but its first.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public void initializePackageContents()
-    {
-        if (isInitialized)
-        {
-            return;
-        }
-        isInitialized = true;
+    // Create resource
+    createResource(eNS_URI);
+  }
 
-        // Initialize package
-        setName(eNAME);
-        setNsPrefix(eNS_PREFIX);
-        setNsURI(eNS_URI);
-
-        // Obtain other dependent packages
-        BPELPackage theBPELPackage = (BPELPackage) EPackage.Registry.INSTANCE.getEPackage(BPELPackage.eNS_URI);
-
-        // Create type parameters
-
-        // Set bounds for type parameters
-
-        // Add supertypes to classes
-        annotationEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-        annotationValueEClass.getESuperTypes().add(theBPELPackage.getExtensibleElement());
-
-        // Initialize classes and features; add operations and parameters
-        initEClass(annotationEClass, Annotation.class, "Annotation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
-        initEAttribute(getAnnotation_Name(), ecorePackage.getEString(), "name", null, 1, 1, Annotation.class, !IS_TRANSIENT,
-                !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-        initEReference(getAnnotation_AnnotationValues(), this.getAnnotationValue(), null, "AnnotationValues", null, 0, -1,
-                Annotation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES,
-                !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-        initEReference(getAnnotation_Annotations(), this.getAnnotation(), null, "Annotations", null, 0, -1, Annotation.class,
-                !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE,
-                !IS_DERIVED, IS_ORDERED);
-
-        initEClass(annotationValueEClass, AnnotationValue.class, "AnnotationValue", !IS_ABSTRACT, !IS_INTERFACE,
-                IS_GENERATED_INSTANCE_CLASS);
-        initEAttribute(getAnnotationValue_Name(), ecorePackage.getEString(), "name", null, 1, 1, AnnotationValue.class,
-                !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-        initEAttribute(getAnnotationValue_Value(), ecorePackage.getEString(), "value", null, 0, 1, AnnotationValue.class,
-                !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
-
-        // Create resource
-        createResource(eNS_URI);
-    }
-
-    private static void registerSerializerAndDeserializer()
-    {
-        BPELExtensionRegistry extensionRegistry = BPELExtensionRegistry.getInstance();
-
-        // Activity
-        InvokeServiceDeserializer invokeServiceDeserializer = new InvokeServiceDeserializer();
-        InvokeServiceSerializer invokeServiceSerializer = new InvokeServiceSerializer();
-        String invokeServiceName = InvokeService.class.getSimpleName();
-        extensionRegistry.registerActivityDeserializer(new QName(ProcessorPackage.eNS_URI,
-                ProcessorConstants.NODE_INVOKE_SERVICE), invokeServiceDeserializer);
-        extensionRegistry.registerActivitySerializer(new QName(ProcessorPackage.eNS_URI, invokeServiceName),
-                invokeServiceSerializer);
-    }
-
-} //RecordPackageImpl
+} // RecordPackageImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordSeqImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordSeqImpl.java
new file mode 100644
index 0000000..721df87
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordSeqImpl.java
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.smila.processing.designer.model.record.RecordPackage;
+import org.eclipse.smila.processing.designer.model.record.RecordSeq;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Seq</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * </p>
+ * 
+ * @generated
+ */
+public class RecordSeqImpl extends RecordValuesImpl implements RecordSeq {
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected RecordSeqImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return RecordPackage.Literals.RECORD_SEQ;
+  }
+
+  /**
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#isSeq()
+   */
+  @Override
+  public boolean isSeq() {
+    return true;
+  }
+
+  /**
+   * @see ExtensionElementImpl#createFixedElement(Document)
+   */
+  @Override
+  protected Element createFixedElement(Document document) {
+    Element element = document.createElementNS(RecordConstants.NS_URI, RecordConstants.ELEMENT_SEQ);
+    element.setPrefix(RecordConstants.NS_PREFIX);
+    return createFixedElement(document, element);
+  }
+
+} // RecordSeqImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordValImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordValImpl.java
new file mode 100644
index 0000000..5c12ebf
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordValImpl.java
@@ -0,0 +1,223 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record.impl;
+
+import org.eclipse.bpel.model.util.ReconciliationHelper;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
+import org.eclipse.smila.processing.designer.model.record.RecordPackage;
+import org.eclipse.smila.processing.designer.model.record.RecordVal;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Val</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ * <li>{@link org.eclipse.smila.processing.designer.model.record.impl.RecordValImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ * </p>
+ * 
+ * @generated
+ */
+public class RecordValImpl extends RecordAnyImpl implements RecordVal {
+  /**
+   * The default value of the '{@link #getValue() <em>Value</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected static final Object VALUE_EDEFAULT = null;
+
+  /**
+   * The cached value of the '{@link #getValue() <em>Value</em>}' attribute. <!-- begin-user-doc --> <!-- end-user-doc
+   * -->
+   * 
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected Object value = VALUE_EDEFAULT;
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected RecordValImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return RecordPackage.Literals.RECORD_VAL;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object getValue() {
+    return value;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @customized
+   */
+  @Override
+  public void setValue(Object newValue) {
+    Type type = Type.getType(newValue);
+    if (type == null) {
+      throw new IllegalArgumentException("That type is not allowed for a value!");
+    }
+
+    Object oldValue = value;
+    value = newValue;
+
+    if (shouldReconcile()) {
+      try {
+        setUpdatingDOM(true);
+        DOMUtils.writeTextContent(getElement(), type.format(newValue));
+      } finally {
+        setUpdatingDOM(false);
+      }
+      ReconciliationHelper.replaceAttribute(this, RecordConstants.ATT_TYPE, type == Type.STRING ? null : type
+        .toString().toLowerCase());
+    }
+
+    if (eNotificationRequired()) {
+      eNotify(new ENotificationImpl(this, Notification.SET, RecordPackage.RECORD_VAL__VALUE, oldValue, value));
+    }
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VAL__VALUE:
+        return getValue();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VAL__VALUE:
+        setValue(newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VAL__VALUE:
+        setValue(VALUE_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VAL__VALUE:
+        return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public String toString() {
+    if (eIsProxy()) {
+      return super.toString();
+    }
+
+    StringBuffer result = new StringBuffer(super.toString());
+    result.append(" (value: ");
+    result.append(value);
+    result.append(')');
+    return result.toString();
+  }
+
+  /**
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny#isVal()
+   */
+  @Override
+  public boolean isVal() {
+    return true;
+  }
+
+  /**
+   * @see RecordVal#getType()
+   */
+  @Override
+  public Type getType() {
+    return value == null ? null : Type.getType(value);
+  }
+
+  /**
+   * @see ExtensionElementImpl#createFixedElement(Document)
+   */
+  @Override
+  protected Element createFixedElement(Document document) {
+    Element element = document.createElementNS(RecordConstants.NS_URI, RecordConstants.ELEMENT_VAL);
+    element.setPrefix(RecordConstants.NS_PREFIX);
+    if (getKey() != null) {
+      element.setAttribute(RecordConstants.ATT_KEY, getKey());
+    }
+    Type type = getType();
+    if (type != null) {
+      if (type != Type.STRING) {
+        element.setAttribute(RecordConstants.ATT_TYPE, type.name().toLowerCase());
+      }
+      element.appendChild(document.createTextNode(type.format(getValue())));
+    }
+    return element;
+  }
+
+} // RecordValImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordValuesImpl.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordValuesImpl.java
new file mode 100644
index 0000000..f1cc207
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/impl/RecordValuesImpl.java
@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ */
+package org.eclipse.smila.processing.designer.model.record.impl;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.*;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.smila.processing.designer.model.processor.util.DOMUtils;
+import org.eclipse.smila.processing.designer.model.record.*;
+import org.eclipse.smila.processing.designer.model.record.util.RecordConstants;
+import org.eclipse.wst.wsdl.internal.impl.WSDLElementImpl;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>Values</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * <ul>
+ * <li>{@link org.eclipse.smila.processing.designer.model.record.impl.RecordValuesImpl#getValues <em>Values</em>}</li>
+ * </ul>
+ * </p>
+ * 
+ * @generated
+ */
+public abstract class RecordValuesImpl extends RecordAnyImpl implements RecordValues {
+  /**
+   * The cached value of the '{@link #getValues() <em>Values</em>}' containment reference list. <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * 
+   * @see #getValues()
+   * @generated
+   * @ordered
+   */
+  protected EList<RecordAny> values;
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected RecordValuesImpl() {
+    super();
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass() {
+    return RecordPackage.Literals.RECORD_VALUES;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public EList<RecordAny> getValues() {
+    if (values == null) {
+      values = new EObjectContainmentEList<RecordAny>(RecordAny.class, this, RecordPackage.RECORD_VALUES__VALUES);
+    }
+    return values;
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VALUES__VALUES:
+        return ((InternalEList<?>) getValues()).basicRemove(otherEnd, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VALUES__VALUES:
+        return getValues();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VALUES__VALUES:
+        getValues().clear();
+        getValues().addAll((Collection<? extends RecordAny>) newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VALUES__VALUES:
+        getValues().clear();
+        return;
+    }
+    super.eUnset(featureID);
+  }
+
+  /**
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID) {
+    switch (featureID) {
+      case RecordPackage.RECORD_VALUES__VALUES:
+        return values != null && !values.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+
+  /**
+   * @see org.eclipse.wst.wsdl.internal.impl.WSDLElementImpl#adoptContent(EReference, Object)
+   */
+  @Override
+  protected void adoptContent(EReference reference, Object object) {
+    if (object instanceof RecordAny && shouldReconcile()) {
+      // Modified ReconciliationHelper.adoptChild for our use case
+      RecordAny value = (RecordAny) object;
+      Element parentElement = getElement();
+      Element valueElement = value.fixElement(getElement().getOwnerDocument());
+      if (valueElement.getParentNode() != parentElement) {
+        try {
+          setUpdatingDOM(true);
+          int index = values.indexOf(value);
+          List<Element> elements =
+            DOMUtils.getChildElements(parentElement, RecordConstants.NS_URI, RecordConstants.ELEMENT_MAP,
+              RecordConstants.ELEMENT_SEQ, RecordConstants.ELEMENT_VAL);
+          DOMUtils.insertIndented(parentElement, valueElement,
+            index >= elements.size() ? null : elements.get(index));
+        } finally {
+          setUpdatingDOM(false);
+        }
+      }
+    }
+    super.adoptContent(reference, object);
+  }
+
+  /**
+   * @see WSDLElementImpl#orphanContent(EReference, Object)
+   */
+  @Override
+  protected void orphanContent(EReference reference, Object obj) {
+    if (obj instanceof RecordAny && shouldReconcile()) {
+      try {
+        setUpdatingDOM(true);
+        RecordAny child = (RecordAny) obj;
+        Element childElement = child.getElement();
+        if (childElement != null && childElement.getParentNode() == getElement()) {
+          DOMUtils.removeIndented(childElement);
+        }
+      } finally {
+        setUpdatingDOM(false);
+      }
+    }
+    super.orphanContent(reference, obj);
+  }
+
+  protected Element createFixedElement(Document document, Element element) {
+    if (getKey() != null) {
+      element.setAttribute(RecordConstants.ATT_KEY, getKey());
+    }
+    for (RecordAny value : getValues()) {
+      DOMUtils.appendIndented(element, value.fixElement(document));
+    }
+    return element;
+  }
+
+} // RecordValuesImpl
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordAdapterFactory.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordAdapterFactory.java
index 16b1bcb..f359c33 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordAdapterFactory.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordAdapterFactory.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record.util;
 
@@ -18,246 +17,288 @@
 import org.eclipse.wst.wsdl.WSDLElement;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Adapter Factory</b> for the model.
- * It provides an adapter <code>createXXX</code> method for each class of the model.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Adapter Factory</b> for the model. It provides an adapter <code>createXXX</code>
+ * method for each class of the model. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.record.RecordPackage
  * @generated
  */
-public class RecordAdapterFactory extends AdapterFactoryImpl
-{
-    /**
-     * The cached model package.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected static RecordPackage modelPackage;
+public class RecordAdapterFactory extends AdapterFactoryImpl {
+  /**
+   * The cached model package. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected static RecordPackage modelPackage;
 
-    /**
-     * Creates an instance of the adapter factory.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public RecordAdapterFactory()
-    {
-        if (modelPackage == null)
-        {
-            modelPackage = RecordPackage.eINSTANCE;
-        }
+  /**
+   * Creates an instance of the adapter factory. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public RecordAdapterFactory() {
+    if (modelPackage == null) {
+      modelPackage = RecordPackage.eINSTANCE;
     }
+  }
 
-    /**
-     * Returns whether this factory is applicable for the type of the object.
-     * <!-- begin-user-doc -->
-     * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
-     * <!-- end-user-doc -->
-     * @return whether this factory is applicable for the type of the object.
-     * @generated
-     */
+  /**
+   * Returns whether this factory is applicable for the type of the object. <!-- begin-user-doc --> This implementation
+   * returns <code>true</code> if the object is either the model's package or is an instance object of the model. <!--
+   * end-user-doc -->
+   * 
+   * @return whether this factory is applicable for the type of the object.
+   * @generated
+   */
+  @Override
+  public boolean isFactoryForType(Object object) {
+    if (object == modelPackage) {
+      return true;
+    }
+    if (object instanceof EObject) {
+      return ((EObject) object).eClass().getEPackage() == modelPackage;
+    }
+    return false;
+  }
+
+  /**
+   * The switch that delegates to the <code>createXXX</code> methods. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected RecordSwitch<Adapter> modelSwitch = new RecordSwitch<Adapter>() {
     @Override
-    public boolean isFactoryForType(Object object)
-    {
-        if (object == modelPackage)
-        {
-            return true;
-        }
-        if (object instanceof EObject)
-        {
-            return ((EObject) object).eClass().getEPackage() == modelPackage;
-        }
-        return false;
+    public Adapter caseRecordMap(RecordMap object) {
+      return createRecordMapAdapter();
     }
 
-    /**
-     * The switch that delegates to the <code>createXXX</code> methods.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected RecordSwitch<Adapter> modelSwitch = new RecordSwitch<Adapter>()
-    {
-        @Override
-        public Adapter caseAnnotation(Annotation object)
-        {
-            return createAnnotationAdapter();
-        }
-
-        @Override
-        public Adapter caseAnnotationValue(AnnotationValue object)
-        {
-            return createAnnotationValueAdapter();
-        }
-
-        @Override
-        public Adapter caseWSDLElement(WSDLElement object)
-        {
-            return createWSDLElementAdapter();
-        }
-
-        @Override
-        public Adapter caseIElementExtensible(ElementExtensible object)
-        {
-            return createIElementExtensibleAdapter();
-        }
-
-        @Override
-        public Adapter caseIAttributeExtensible(AttributeExtensible object)
-        {
-            return createIAttributeExtensibleAdapter();
-        }
-
-        @Override
-        public Adapter caseExtensibleElement(ExtensibleElement object)
-        {
-            return createExtensibleElementAdapter();
-        }
-
-        @Override
-        public Adapter caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object)
-        {
-            return createBPEL_ExtensibleElementAdapter();
-        }
-
-        @Override
-        public Adapter defaultCase(EObject object)
-        {
-            return createEObjectAdapter();
-        }
-    };
-
-    /**
-     * Creates an adapter for the <code>target</code>.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @param target the object to adapt.
-     * @return the adapter for the <code>target</code>.
-     * @generated
-     */
     @Override
-    public Adapter createAdapter(Notifier target)
-    {
-        return modelSwitch.doSwitch((EObject) target);
+    public Adapter caseRecordSeq(RecordSeq object) {
+      return createRecordSeqAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.Annotation <em>Annotation</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.record.Annotation
-     * @generated
-     */
-    public Adapter createAnnotationAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseRecordVal(RecordVal object) {
+      return createRecordValAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.AnnotationValue <em>Annotation Value</em>}'.
-     * <!-- begin-user-doc -->
-    * This default implementation returns null so that we can easily ignore cases;
-    * it's useful to ignore a case when inheritance will catch all the cases anyway.
-    * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.smila.processing.designer.model.record.AnnotationValue
-     * @generated
-     */
-    public Adapter createAnnotationValueAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseRecordAny(RecordAny object) {
+      return createRecordAnyAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.WSDLElement <em>Element</em>}'.
-     * <!-- begin-user-doc -->
-    * This default implementation returns null so that we can easily ignore cases;
-    * it's useful to ignore a case when inheritance will catch all the cases anyway.
-    * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.wst.wsdl.WSDLElement
-     * @generated
-     */
-    public Adapter createWSDLElementAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseExtensionElement(ExtensionElement object) {
+      return createExtensionElementAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.ElementExtensible <em>IElement Extensible</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see javax.wsdl.extensions.ElementExtensible
-     * @generated
-     */
-    public Adapter createIElementExtensibleAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseRecordValues(RecordValues object) {
+      return createRecordValuesAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.AttributeExtensible <em>IAttribute Extensible</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see javax.wsdl.extensions.AttributeExtensible
-     * @generated
-     */
-    public Adapter createIAttributeExtensibleAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseWSDLElement(WSDLElement object) {
+      return createWSDLElementAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.ExtensibleElement <em>Extensible Element</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.wst.wsdl.ExtensibleElement
-     * @generated
-     */
-    public Adapter createExtensibleElementAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseIElementExtensible(ElementExtensible object) {
+      return createIElementExtensibleAdapter();
     }
 
-    /**
-     * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.ExtensibleElement <em>Extensible Element</em>}'.
-     * <!-- begin-user-doc -->
-     * This default implementation returns null so that we can easily ignore cases;
-     * it's useful to ignore a case when inheritance will catch all the cases anyway.
-     * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @see org.eclipse.bpel.model.ExtensibleElement
-     * @generated
-     */
-    public Adapter createBPEL_ExtensibleElementAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseIAttributeExtensible(AttributeExtensible object) {
+      return createIAttributeExtensibleAdapter();
     }
 
-    /**
-     * Creates a new adapter for the default case.
-     * <!-- begin-user-doc -->
-    * This default implementation returns null.
-    * <!-- end-user-doc -->
-     * @return the new adapter.
-     * @generated
-     */
-    public Adapter createEObjectAdapter()
-    {
-        return null;
+    @Override
+    public Adapter caseExtensibleElement(ExtensibleElement object) {
+      return createExtensibleElementAdapter();
     }
 
-} //RecordAdapterFactory
+    @Override
+    public Adapter caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object) {
+      return createBPEL_ExtensibleElementAdapter();
+    }
+
+    @Override
+    public Adapter defaultCase(EObject object) {
+      return createEObjectAdapter();
+    }
+  };
+
+  /**
+   * Creates an adapter for the <code>target</code>. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @param target
+   *          the object to adapt.
+   * @return the adapter for the <code>target</code>.
+   * @generated
+   */
+  @Override
+  public Adapter createAdapter(Notifier target) {
+    return modelSwitch.doSwitch((EObject) target);
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.RecordMap
+   * <em>Map</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordMap
+   * @generated
+   */
+  public Adapter createRecordMapAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.RecordSeq
+   * <em>Seq</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordSeq
+   * @generated
+   */
+  public Adapter createRecordSeqAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.RecordVal
+   * <em>Val</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordVal
+   * @generated
+   */
+  public Adapter createRecordValAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.smila.processing.designer.model.record.RecordAny
+   * <em>Any</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can easily ignore
+   * cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordAny
+   * @generated
+   */
+  public Adapter createRecordAnyAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.record.ExtensionElement <em>Extension Element</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.ExtensionElement
+   * @generated
+   */
+  public Adapter createExtensionElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '
+   * {@link org.eclipse.smila.processing.designer.model.record.RecordValues <em>Values</em>}'. <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases; it's useful to ignore a case when
+   * inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.smila.processing.designer.model.record.RecordValues
+   * @generated
+   */
+  public Adapter createRecordValuesAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.WSDLElement <em>Element</em>}'. <!--
+   * begin-user-doc --> This default implementation returns null so that we can easily ignore cases; it's useful to
+   * ignore a case when inheritance will catch all the cases anyway. <!-- end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.wst.wsdl.WSDLElement
+   * @generated
+   */
+  public Adapter createWSDLElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.ElementExtensible
+   * <em>IElement Extensible</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see javax.wsdl.extensions.ElementExtensible
+   * @generated
+   */
+  public Adapter createIElementExtensibleAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link javax.wsdl.extensions.AttributeExtensible
+   * <em>IAttribute Extensible</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see javax.wsdl.extensions.AttributeExtensible
+   * @generated
+   */
+  public Adapter createIAttributeExtensibleAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.wst.wsdl.ExtensibleElement
+   * <em>Extensible Element</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.wst.wsdl.ExtensibleElement
+   * @generated
+   */
+  public Adapter createExtensibleElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.bpel.model.ExtensibleElement
+   * <em>Extensible Element</em>}'. <!-- begin-user-doc --> This default implementation returns null so that we can
+   * easily ignore cases; it's useful to ignore a case when inheritance will catch all the cases anyway. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @see org.eclipse.bpel.model.ExtensibleElement
+   * @generated
+   */
+  public Adapter createBPEL_ExtensibleElementAdapter() {
+    return null;
+  }
+
+  /**
+   * Creates a new adapter for the default case. <!-- begin-user-doc --> This default implementation returns null. <!--
+   * end-user-doc -->
+   * 
+   * @return the new adapter.
+   * @generated
+   */
+  public Adapter createEObjectAdapter() {
+    return null;
+  }
+
+} // RecordAdapterFactory
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordConstants.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordConstants.java
index 010794b..67c5560 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordConstants.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordConstants.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record.util;
 
@@ -15,18 +14,23 @@
  * 
  * @author Lars Kunze
  */
-public class RecordConstants
-{
-    // Node names
-    public static final String NODE_AN = "An";
-    public static final String NODE_V = "V";
+public class RecordConstants {
+  // Namespace URI
+  public static final String NS_URI = RecordPackage.eNS_URI;
 
-    // Attribute names
-    public static final String ATT_N = "n";
-    public static final String ATT_INPUT = "input";
-    public static final String ATT_OUTPUT = "output";
-    public static final String ATT_NAME = "name";
+  // Namespace prefix
+  public static final String NS_PREFIX = RecordPackage.eNS_PREFIX;
 
-    // Namespace
-    public static final String NS_PREFIX = RecordPackage.eINSTANCE.getNsPrefix();
+  // Element names
+  public static final String ELEMENT_VAL = "Val";
+
+  public static final String ELEMENT_SEQ = "Seq";
+
+  public static final String ELEMENT_MAP = "Map";
+
+  // Attribute names
+  public static final String ATT_KEY = "key";
+
+  public static final String ATT_TYPE = "type";
+
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordSwitch.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordSwitch.java
index 034f5fe..7305323 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordSwitch.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordSwitch.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record.util;
 
@@ -18,276 +17,413 @@
 import org.eclipse.wst.wsdl.WSDLElement;
 
 /**
- * <!-- begin-user-doc -->
- * The <b>Switch</b> for the model's inheritance hierarchy.
- * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
- * to invoke the <code>caseXXX</code> method for each class of the model,
- * starting with the actual class of the object
- * and proceeding up the inheritance hierarchy
- * until a non-null result is returned,
- * which is the result of the switch.
- * <!-- end-user-doc -->
+ * <!-- begin-user-doc --> The <b>Switch</b> for the model's inheritance hierarchy. It supports the call
+ * {@link #doSwitch(EObject) doSwitch(object)} to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object and proceeding up the inheritance hierarchy until a non-null result is
+ * returned, which is the result of the switch. <!-- end-user-doc -->
+ * 
  * @see org.eclipse.smila.processing.designer.model.record.RecordPackage
  * @generated
  */
-public class RecordSwitch<T>
-{
-    /**
-     * The cached model package
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    protected static RecordPackage modelPackage;
+public class RecordSwitch<T> {
+  /**
+   * The cached model package <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  protected static RecordPackage modelPackage;
 
-    /**
-     * Creates an instance of the switch.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @generated
-     */
-    public RecordSwitch()
-    {
-        if (modelPackage == null)
-        {
-            modelPackage = RecordPackage.eINSTANCE;
+  /**
+   * Creates an instance of the switch. <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @generated
+   */
+  public RecordSwitch() {
+    if (modelPackage == null) {
+      modelPackage = RecordPackage.eINSTANCE;
+    }
+  }
+
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  public T doSwitch(EObject theEObject) {
+    return doSwitch(theEObject.eClass(), theEObject);
+  }
+
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  protected T doSwitch(EClass theEClass, EObject theEObject) {
+    if (theEClass.eContainer() == modelPackage) {
+      return doSwitch(theEClass.getClassifierID(), theEObject);
+    } else {
+      List<EClass> eSuperTypes = theEClass.getESuperTypes();
+      return eSuperTypes.isEmpty() ? defaultCase(theEObject) : doSwitch(eSuperTypes.get(0), theEObject);
+    }
+  }
+
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc --> <!-- end-user-doc -->
+   * 
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  protected T doSwitch(int classifierID, EObject theEObject) {
+    switch (classifierID) {
+      case RecordPackage.RECORD_MAP: {
+        RecordMap recordMap = (RecordMap) theEObject;
+        T result = caseRecordMap(recordMap);
+        if (result == null) {
+          result = caseRecordValues(recordMap);
         }
-    }
-
-    /**
-     * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-     * @generated
-     */
-    public T doSwitch(EObject theEObject)
-    {
-        return doSwitch(theEObject.eClass(), theEObject);
-    }
-
-    /**
-     * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-     * @generated
-     */
-    protected T doSwitch(EClass theEClass, EObject theEObject)
-    {
-        if (theEClass.eContainer() == modelPackage)
-        {
-            return doSwitch(theEClass.getClassifierID(), theEObject);
+        if (result == null) {
+          result = caseRecordAny(recordMap);
         }
-        else
-        {
-            List<EClass> eSuperTypes = theEClass.getESuperTypes();
-            return eSuperTypes.isEmpty() ? defaultCase(theEObject) : doSwitch(eSuperTypes.get(0), theEObject);
+        if (result == null) {
+          result = caseExtensionElement(recordMap);
         }
-    }
-
-    /**
-     * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
-     * <!-- begin-user-doc -->
-     * <!-- end-user-doc -->
-     * @return the first non-null result returned by a <code>caseXXX</code> call.
-     * @generated
-     */
-    protected T doSwitch(int classifierID, EObject theEObject)
-    {
-        switch (classifierID)
-        {
-            case RecordPackage.ANNOTATION :
-            {
-                Annotation annotation = (Annotation) theEObject;
-                T result = caseAnnotation(annotation);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(annotation);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(annotation);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(annotation);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(annotation);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(annotation);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            case RecordPackage.ANNOTATION_VALUE :
-            {
-                AnnotationValue annotationValue = (AnnotationValue) theEObject;
-                T result = caseAnnotationValue(annotationValue);
-                if (result == null)
-                {
-                    result = caseBPEL_ExtensibleElement(annotationValue);
-                }
-                if (result == null)
-                {
-                    result = caseExtensibleElement(annotationValue);
-                }
-                if (result == null)
-                {
-                    result = caseWSDLElement(annotationValue);
-                }
-                if (result == null)
-                {
-                    result = caseIElementExtensible(annotationValue);
-                }
-                if (result == null)
-                {
-                    result = caseIAttributeExtensible(annotationValue);
-                }
-                if (result == null)
-                {
-                    result = defaultCase(theEObject);
-                }
-                return result;
-            }
-            default :
-                return defaultCase(theEObject);
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(recordMap);
         }
+        if (result == null) {
+          result = caseExtensibleElement(recordMap);
+        }
+        if (result == null) {
+          result = caseWSDLElement(recordMap);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(recordMap);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(recordMap);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case RecordPackage.RECORD_SEQ: {
+        RecordSeq recordSeq = (RecordSeq) theEObject;
+        T result = caseRecordSeq(recordSeq);
+        if (result == null) {
+          result = caseRecordValues(recordSeq);
+        }
+        if (result == null) {
+          result = caseRecordAny(recordSeq);
+        }
+        if (result == null) {
+          result = caseExtensionElement(recordSeq);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(recordSeq);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(recordSeq);
+        }
+        if (result == null) {
+          result = caseWSDLElement(recordSeq);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(recordSeq);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(recordSeq);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case RecordPackage.RECORD_VAL: {
+        RecordVal recordVal = (RecordVal) theEObject;
+        T result = caseRecordVal(recordVal);
+        if (result == null) {
+          result = caseRecordAny(recordVal);
+        }
+        if (result == null) {
+          result = caseExtensionElement(recordVal);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(recordVal);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(recordVal);
+        }
+        if (result == null) {
+          result = caseWSDLElement(recordVal);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(recordVal);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(recordVal);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case RecordPackage.RECORD_ANY: {
+        RecordAny recordAny = (RecordAny) theEObject;
+        T result = caseRecordAny(recordAny);
+        if (result == null) {
+          result = caseExtensionElement(recordAny);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(recordAny);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(recordAny);
+        }
+        if (result == null) {
+          result = caseWSDLElement(recordAny);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(recordAny);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(recordAny);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case RecordPackage.EXTENSION_ELEMENT: {
+        ExtensionElement extensionElement = (ExtensionElement) theEObject;
+        T result = caseExtensionElement(extensionElement);
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(extensionElement);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(extensionElement);
+        }
+        if (result == null) {
+          result = caseWSDLElement(extensionElement);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(extensionElement);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(extensionElement);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      case RecordPackage.RECORD_VALUES: {
+        RecordValues recordValues = (RecordValues) theEObject;
+        T result = caseRecordValues(recordValues);
+        if (result == null) {
+          result = caseRecordAny(recordValues);
+        }
+        if (result == null) {
+          result = caseExtensionElement(recordValues);
+        }
+        if (result == null) {
+          result = caseBPEL_ExtensibleElement(recordValues);
+        }
+        if (result == null) {
+          result = caseExtensibleElement(recordValues);
+        }
+        if (result == null) {
+          result = caseWSDLElement(recordValues);
+        }
+        if (result == null) {
+          result = caseIElementExtensible(recordValues);
+        }
+        if (result == null) {
+          result = caseIAttributeExtensible(recordValues);
+        }
+        if (result == null) {
+          result = defaultCase(theEObject);
+        }
+        return result;
+      }
+      default:
+        return defaultCase(theEObject);
     }
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Annotation</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Annotation</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseAnnotation(Annotation object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Map</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Map</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordMap(RecordMap object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Annotation Value</em>'.
-     * <!-- begin-user-doc -->
-    * This implementation returns null;
-    * returning a non-null result will terminate the switch.
-    * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Annotation Value</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseAnnotationValue(AnnotationValue object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Seq</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Seq</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordSeq(RecordSeq object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Element</em>'.
-     * <!-- begin-user-doc -->
-    * This implementation returns null;
-    * returning a non-null result will terminate the switch.
-    * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Element</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseWSDLElement(WSDLElement object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Val</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Val</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordVal(RecordVal object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>IElement Extensible</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>IElement Extensible</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseIElementExtensible(ElementExtensible object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Any</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Any</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordAny(RecordAny object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseIAttributeExtensible(AttributeExtensible object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extension Element</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extension Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseExtensionElement(ExtensionElement object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseExtensibleElement(ExtensibleElement object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Values</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Values</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRecordValues(RecordValues object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * <!-- begin-user-doc -->
-     * This implementation returns null;
-     * returning a non-null result will terminate the switch.
-     * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
-     * @generated
-     */
-    public T caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Element</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseWSDLElement(WSDLElement object) {
+    return null;
+  }
 
-    /**
-     * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
-     * <!-- begin-user-doc -->
-    * This implementation returns null;
-    * returning a non-null result will terminate the switch, but this is the last case anyway.
-    * <!-- end-user-doc -->
-     * @param object the target of the switch.
-     * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
-     * @see #doSwitch(org.eclipse.emf.ecore.EObject)
-     * @generated
-     */
-    public T defaultCase(EObject object)
-    {
-        return null;
-    }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>IElement Extensible</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>IElement Extensible</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIElementExtensible(ElementExtensible object) {
+    return null;
+  }
 
-} //RecordSwitch
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'. <!--
+   * begin-user-doc --> This implementation returns null; returning a non-null result will terminate the switch. <!--
+   * end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>IAttribute Extensible</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIAttributeExtensible(AttributeExtensible object) {
+    return null;
+  }
+
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseExtensibleElement(ExtensibleElement object) {
+    return null;
+  }
+
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Extensible Element</em>'. <!-- begin-user-doc
+   * --> This implementation returns null; returning a non-null result will terminate the switch. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Extensible Element</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBPEL_ExtensibleElement(org.eclipse.bpel.model.ExtensibleElement object) {
+    return null;
+  }
+
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>EObject</em>'. <!-- begin-user-doc --> This
+   * implementation returns null; returning a non-null result will terminate the switch, but this is the last case
+   * anyway. <!-- end-user-doc -->
+   * 
+   * @param object
+   *          the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+   * @generated
+   */
+  public T defaultCase(EObject object) {
+    return null;
+  }
+
+} // RecordSwitch
diff --git a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordUtils.java b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordUtils.java
index 74eb801..bb10bef 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordUtils.java
+++ b/tooling/org.eclipse.smila.processing.designer.model/code/src/org/eclipse/smila/processing/designer/model/record/util/RecordUtils.java
@@ -1,15 +1,13 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.model.record.util;
 
 import org.eclipse.bpel.model.Process;
 import org.eclipse.bpel.model.adapters.INamespaceMap;
 import org.eclipse.bpel.model.util.BPELUtils;
-import org.eclipse.smila.processing.designer.model.record.RecordPackage;
 
 /**
  * Utils for the Record package.
@@ -18,22 +16,20 @@
  * 
  * @author Lars Kunze
  */
-public class RecordUtils
-{
-    /**
-     * Adds the SMILA namespace to the given process
-     * @param process
-     * @return the preferred namespace prefix
-     */
-    public static String addNamespace(Process process)
-    {
-        String nsPrefix = RecordPackage.eINSTANCE.getNsPrefix();
-        if (process != null)
-        { // FIXME: Workaround for jUnit tests
-            String nsURI = RecordPackage.eINSTANCE.getNsURI();
-            INamespaceMap<String, String> nsMap = BPELUtils.getNamespaceMap(process);
-            nsMap.put(nsPrefix, nsURI);
-        }
-        return nsPrefix;
+public class RecordUtils {
+  /**
+   * Adds the SMILA namespace to the given process
+   * 
+   * @param process
+   * @return the preferred namespace prefix
+   */
+  public static String addNamespace(Process process) {
+    String nsPrefix = RecordConstants.NS_PREFIX;
+    if (process != null) { // FIXME: Workaround for jUnit tests
+      String nsURI = RecordConstants.NS_URI;
+      INamespaceMap<String, String> nsMap = BPELUtils.getNamespaceMap(process);
+      nsMap.put(nsPrefix, nsURI);
     }
+    return nsPrefix;
+  }
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.ecore b/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.ecore
index 8a2073c..6fefc91 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.ecore
+++ b/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.ecore
@@ -3,43 +3,21 @@
     xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="processor"
     nsURI="http://www.eclipse.org/smila/processor" nsPrefix="proc">
-  <eClassifiers xsi:type="ecore:EClass" name="InvokePipelet" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensionActivity">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="pipelet" ordered="false"
-        lowerBound="1" eType="#//Pipelet" changeable="false" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="variables" ordered="false"
-        lowerBound="1" eType="#//Variables" changeable="false" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="pipeletConfiguration" ordered="false"
-        lowerBound="1" eType="#//PipeletConfiguration" changeable="false" containment="true"/>
+  <eClassifiers xsi:type="ecore:EClass" name="InvokePipelet" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensionActivity smila-record.ecore#//ExtensionElement">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="pipelet" lowerBound="1"
+        eType="#//Pipelet" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="variables" lowerBound="1"
+        eType="#//Variables" containment="true"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="configuration" lowerBound="1"
+        eType="#//Configuration" containment="true"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Pipelet" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
+  <eClassifiers xsi:type="ecore:EClass" name="Pipelet" eSuperTypes="smila-record.ecore#//ExtensionElement">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="class" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Variables" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
+  <eClassifiers xsi:type="ecore:EClass" name="Variables" eSuperTypes="smila-record.ecore#//ExtensionElement">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="input" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="output" lowerBound="1"
         eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Property" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="PipeletConfiguration" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="properties" upperBound="-1"
-        eType="#//Property" containment="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="InvokeService" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensionActivity">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="service" ordered="false"
-        lowerBound="1" eType="#//Service" changeable="false" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="variables" ordered="false"
-        lowerBound="1" eType="#//Variables" changeable="false" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="setAnnotations" eType="#//SetAnnotations"
-        changeable="false" containment="true"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="Service" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-  </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="SetAnnotations" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
-    <eStructuralFeatures xsi:type="ecore:EReference" name="Annotations" upperBound="-1"
-        eType="ecore:EClass smila-record.ecore#//Annotation" containment="true"/>
-  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="Configuration" eSuperTypes="smila-record.ecore#//RecordMap"/>
 </ecore:EPackage>
diff --git a/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.genmodel b/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.genmodel
index 1cabbca..c8abf28 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.genmodel
+++ b/tooling/org.eclipse.smila.processing.designer.model/model/smila-processor.genmodel
@@ -2,16 +2,17 @@
 <genmodel:GenModel xmi:version="2.0"
     xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
     xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="Copyright (c) 2010 Attensity Europe GmbH.&#xD;&#xA;All rights reserved.&#xD;&#xA;This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html"
-    modelDirectory="/org.eclipse.smila.processing.designer.model/src" modelPluginID="org.eclipse.smila.processing.designer.model"
-    modelName="Smila-processor" importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0"
-    copyrightFields="false" usedGenPackages="../../org.eclipse.bpel.model/src/model/bpel.genmodel#//model ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//partnerlinktype ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//messageproperties platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore smila-record.genmodel#//record platform:/plugin/org.eclipse.wst.wsdl/model/WSDL.genmodel#//wsdl platform:/plugin/org.eclipse.xsd/model/XSD.genmodel#//xsd">
+    modelDirectory="/org.eclipse.smila.processing.designer.model/code/src" editDirectory="/org.eclipse.smila.processing.designer.model.edit/code/src"
+    modelPluginID="org.eclipse.smila.processing.designer.model" modelName="Smila-processor"
+    importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0" copyrightFields="false"
+    usedGenPackages="../../org.eclipse.bpel.model/src/model/bpel.genmodel#//model ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//partnerlinktype ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//messageproperties platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore platform:/plugin/org.eclipse.wst.wsdl/model/WSDL.genmodel#//wsdl platform:/plugin/org.eclipse.xsd/model/XSD.genmodel#//xsd">
   <foreignModel>smila-processor.ecore</foreignModel>
   <genPackages prefix="Processor" basePackage="org.eclipse.smila.processing.designer.model"
       disposableProviderFactory="true" ecorePackage="smila-processor.ecore#/">
     <genClasses ecoreClass="smila-processor.ecore#//InvokePipelet">
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokePipelet/pipelet"/>
       <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokePipelet/variables"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokePipelet/pipeletConfiguration"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokePipelet/configuration"/>
     </genClasses>
     <genClasses ecoreClass="smila-processor.ecore#//Pipelet">
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-processor.ecore#//Pipelet/class"/>
@@ -20,23 +21,24 @@
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-processor.ecore#//Variables/input"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-processor.ecore#//Variables/output"/>
     </genClasses>
-    <genClasses ecoreClass="smila-processor.ecore#//Property">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-processor.ecore#//Property/name"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-processor.ecore#//Property/value"/>
+    <genClasses ecoreClass="smila-processor.ecore#//Configuration"/>
+  </genPackages>
+  <genPackages prefix="Record" basePackage="org.eclipse.smila.processing.designer.model"
+      disposableProviderFactory="true" ecorePackage="smila-record.ecore#/">
+    <genClasses ecoreClass="smila-record.ecore#//RecordMap">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-record.ecore#//RecordMap/values"/>
     </genClasses>
-    <genClasses ecoreClass="smila-processor.ecore#//PipeletConfiguration">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference smila-processor.ecore#//PipeletConfiguration/properties"/>
+    <genClasses ecoreClass="smila-record.ecore#//RecordSeq">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-record.ecore#//RecordSeq/values"/>
     </genClasses>
-    <genClasses ecoreClass="smila-processor.ecore#//InvokeService">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokeService/service"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokeService/variables"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference smila-processor.ecore#//InvokeService/setAnnotations"/>
+    <genClasses ecoreClass="smila-record.ecore#//RecordVal">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//RecordVal/value"/>
     </genClasses>
-    <genClasses ecoreClass="smila-processor.ecore#//Service">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-processor.ecore#//Service/name"/>
+    <genClasses image="false" ecoreClass="smila-record.ecore#//RecordAny">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//RecordAny/key"/>
     </genClasses>
-    <genClasses ecoreClass="smila-processor.ecore#//SetAnnotations">
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-processor.ecore#//SetAnnotations/Annotations"/>
+    <genClasses image="false" ecoreClass="smila-record.ecore#//ExtensionElement">
+      <genOperations ecoreOperation="smila-record.ecore#//ExtensionElement/fixElement"/>
     </genClasses>
   </genPackages>
 </genmodel:GenModel>
diff --git a/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.ecore b/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.ecore
index a66df7f..a52a30c 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.ecore
+++ b/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.ecore
@@ -3,15 +3,21 @@
     xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="record"
     nsURI="http://www.eclipse.org/smila/record" nsPrefix="rec">
-  <eClassifiers xsi:type="ecore:EClass" name="Annotation" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="AnnotationValues" upperBound="-1"
-        eType="#//AnnotationValue" containment="true"/>
-    <eStructuralFeatures xsi:type="ecore:EReference" name="Annotations" upperBound="-1"
-        eType="#//Annotation" containment="true"/>
+  <eClassifiers xsi:type="ecore:EClass" name="RecordMap" eSuperTypes="#//RecordValues"/>
+  <eClassifiers xsi:type="ecore:EClass" name="RecordSeq" eSuperTypes="#//RecordValues"/>
+  <eClassifiers xsi:type="ecore:EClass" name="RecordVal" eSuperTypes="#//RecordAny">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" unique="false" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EJavaObject"/>
   </eClassifiers>
-  <eClassifiers xsi:type="ecore:EClass" name="AnnotationValue" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  <eClassifiers xsi:type="ecore:EClass" name="RecordAny" abstract="true" eSuperTypes="#//ExtensionElement">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="key" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="ExtensionElement" abstract="true" eSuperTypes="../../org.eclipse.bpel.model/src/model/bpel.ecore#//ExtensibleElement">
+    <eOperations name="fixElement" eType="ecore:EDataType platform:/plugin/org.eclipse.wst.wsdl/model/WSDL.ecore#//DOMElement">
+      <eParameters name="document" eType="ecore:EDataType platform:/plugin/org.eclipse.wst.wsdl/model/WSDL.ecore#//DOMDocument"/>
+    </eOperations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="RecordValues" abstract="true" eSuperTypes="#//RecordAny">
+    <eStructuralFeatures xsi:type="ecore:EReference" name="values" upperBound="-1"
+        eType="#//RecordAny" containment="true"/>
   </eClassifiers>
 </ecore:EPackage>
diff --git a/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.genmodel b/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.genmodel
index aadbe6a..dc5e2ca 100644
--- a/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.genmodel
+++ b/tooling/org.eclipse.smila.processing.designer.model/model/smila-record.genmodel
@@ -2,20 +2,24 @@
 <genmodel:GenModel xmi:version="2.0"
     xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
     xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="Copyright (c) 2010 Attensity Europe GmbH.&#xD;&#xA;All rights reserved.&#xD;&#xA;This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0&#xD;&#xA;which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html"
-    modelDirectory="/org.eclipse.smila.processing.designer.model/src" modelPluginID="org.eclipse.smila.processing.designer.model"
-    modelName="Smila-record" importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0"
-    copyrightFields="false" usedGenPackages="../../org.eclipse.bpel.model/src/model/bpel.genmodel#//model ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//partnerlinktype ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//messageproperties platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore platform:/plugin/org.eclipse.wst.wsdl/model/WSDL.genmodel#//wsdl platform:/plugin/org.eclipse.xsd/model/XSD.genmodel#//xsd">
+    modelDirectory="/org.eclipse.smila.processing.designer.model/code/src" editDirectory="/org.eclipse.smila.processing.designer.model.edit/code/src"
+    modelPluginID="org.eclipse.smila.processing.designer.model" modelName="Smila-record"
+    importerID="org.eclipse.emf.importer.ecore" complianceLevel="6.0" copyrightFields="false"
+    usedGenPackages="../../org.eclipse.bpel.model/src/model/bpel.genmodel#//model ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//partnerlinktype ../../org.eclipse.bpel.model/src/model/bpel.genmodel#//messageproperties platform:/plugin/org.eclipse.emf.ecore/model/Ecore.genmodel#//ecore platform:/plugin/org.eclipse.wst.wsdl/model/WSDL.genmodel#//wsdl platform:/plugin/org.eclipse.xsd/model/XSD.genmodel#//xsd">
   <foreignModel>smila-record.ecore</foreignModel>
   <genPackages prefix="Record" basePackage="org.eclipse.smila.processing.designer.model"
       disposableProviderFactory="true" ecorePackage="smila-record.ecore#/">
-    <genClasses ecoreClass="smila-record.ecore#//Annotation">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//Annotation/name"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-record.ecore#//Annotation/AnnotationValues"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-record.ecore#//Annotation/Annotations"/>
+    <genClasses ecoreClass="smila-record.ecore#//RecordMap">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-record.ecore#//RecordMap/values"/>
     </genClasses>
-    <genClasses ecoreClass="smila-record.ecore#//AnnotationValue">
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//AnnotationValue/name"/>
-      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//AnnotationValue/value"/>
+    <genClasses ecoreClass="smila-record.ecore#//RecordSeq">
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference smila-record.ecore#//RecordSeq/values"/>
+    </genClasses>
+    <genClasses ecoreClass="smila-record.ecore#//RecordVal">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//RecordVal/value"/>
+    </genClasses>
+    <genClasses image="false" ecoreClass="smila-record.ecore#//RecordAny">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute smila-record.ecore#//RecordAny/key"/>
     </genClasses>
   </genPackages>
 </genmodel:GenModel>
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/.classpath b/tooling/org.eclipse.smila.processing.designer.ui/.classpath
index cef6295..e577adf 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/.classpath
+++ b/tooling/org.eclipse.smila.processing.designer.ui/.classpath
@@ -1,7 +1,7 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="code/src"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
-	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-	<classpathentry kind="output" path="code/bin"/>
-</classpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="code/src"/>
+	<classpathentry kind="output" path="code/bin"/>
+</classpath>
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.core.prefs b/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.core.prefs
index 53e68a1..0481e81 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.core.prefs
+++ b/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.core.prefs
@@ -1,4 +1,4 @@
-#Wed Dec 08 11:07:58 CET 2010
+#Tue Mar 08 09:26:01 CET 2011
 eclipse.preferences.version=1
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 org.eclipse.jdt.core.compiler.compliance=1.6
@@ -14,9 +14,9 @@
 org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
 org.eclipse.jdt.core.formatter.alignment_for_assignment=16
 org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_compact_if=52
-org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=16
-org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=16
 org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
 org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
 org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
@@ -30,7 +30,7 @@
 org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
 org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
 org.eclipse.jdt.core.formatter.blank_lines_after_package=1
-org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_field=1
 org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
 org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
 org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
@@ -38,36 +38,36 @@
 org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
 org.eclipse.jdt.core.formatter.blank_lines_before_package=0
 org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
-org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=0
-org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=next_line
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
 org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
-org.eclipse.jdt.core.formatter.brace_position_for_block=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_switch=next_line
-org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=next_line
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=true
-org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=true
-org.eclipse.jdt.core.formatter.comment.format_block_comments=false
-org.eclipse.jdt.core.formatter.comment.format_header=false
-org.eclipse.jdt.core.formatter.comment.format_html=false
-org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=false
-org.eclipse.jdt.core.formatter.comment.format_line_comments=false
-org.eclipse.jdt.core.formatter.comment.format_source_code=false
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=true
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
 org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
-org.eclipse.jdt.core.formatter.comment.indent_root_tags=false
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
 org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
-org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
-org.eclipse.jdt.core.formatter.comment.line_length=256
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=120
 org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
 org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
 org.eclipse.jdt.core.formatter.compact_else_if=true
-org.eclipse.jdt.core.formatter.continuation_indentation=2
-org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.continuation_indentation=1
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=1
 org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
 org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
 org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
@@ -82,17 +82,17 @@
 org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
 org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
 org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
-org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.indentation.size=2
 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=insert
-org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
 org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
@@ -138,7 +138,7 @@
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
@@ -167,7 +167,7 @@
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
-org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
@@ -184,11 +184,11 @@
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
-org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
 org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
@@ -261,14 +261,14 @@
 org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
 org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
 org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
-org.eclipse.jdt.core.formatter.lineSplit=128
+org.eclipse.jdt.core.formatter.lineSplit=116
 org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
 org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
 org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
-org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=false
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
 org.eclipse.jdt.core.formatter.tabulation.char=space
-org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.tabulation.size=2
 org.eclipse.jdt.core.formatter.use_on_off_tags=false
 org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
 org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.ui.prefs b/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.ui.prefs
index d0c62e9..0510282 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.ui.prefs
+++ b/tooling/org.eclipse.smila.processing.designer.ui/.settings/org.eclipse.jdt.ui.prefs
@@ -1,7 +1,60 @@
-#Wed Dec 08 11:07:59 CET 2010
+#Tue Mar 08 09:27:55 CET 2011
+cleanup.add_default_serial_version_id=true
+cleanup.add_generated_serial_version_id=false
+cleanup.add_missing_annotations=true
+cleanup.add_missing_deprecated_annotations=true
+cleanup.add_missing_methods=false
+cleanup.add_missing_nls_tags=false
+cleanup.add_missing_override_annotations=true
+cleanup.add_missing_override_annotations_interface_methods=true
+cleanup.add_serial_version_id=false
+cleanup.always_use_blocks=true
+cleanup.always_use_parentheses_in_expressions=false
+cleanup.always_use_this_for_non_static_field_access=false
+cleanup.always_use_this_for_non_static_method_access=false
+cleanup.convert_to_enhanced_for_loop=false
+cleanup.correct_indentation=true
+cleanup.format_source_code=true
+cleanup.format_source_code_changes_only=false
+cleanup.make_local_variable_final=true
+cleanup.make_parameters_final=false
+cleanup.make_private_fields_final=true
+cleanup.make_type_abstract_if_missing_method=false
+cleanup.make_variable_declarations_final=false
+cleanup.never_use_blocks=false
+cleanup.never_use_parentheses_in_expressions=true
+cleanup.organize_imports=true
+cleanup.qualify_static_field_accesses_with_declaring_class=false
+cleanup.qualify_static_member_accesses_through_instances_with_declaring_class=true
+cleanup.qualify_static_member_accesses_through_subtypes_with_declaring_class=true
+cleanup.qualify_static_member_accesses_with_declaring_class=false
+cleanup.qualify_static_method_accesses_with_declaring_class=false
+cleanup.remove_private_constructors=true
+cleanup.remove_trailing_whitespaces=true
+cleanup.remove_trailing_whitespaces_all=true
+cleanup.remove_trailing_whitespaces_ignore_empty=false
+cleanup.remove_unnecessary_casts=true
+cleanup.remove_unnecessary_nls_tags=true
+cleanup.remove_unused_imports=true
+cleanup.remove_unused_local_variables=false
+cleanup.remove_unused_private_fields=true
+cleanup.remove_unused_private_members=false
+cleanup.remove_unused_private_methods=true
+cleanup.remove_unused_private_types=true
+cleanup.sort_members=false
+cleanup.sort_members_all=false
+cleanup.use_blocks=true
+cleanup.use_blocks_only_for_return_and_throw=false
+cleanup.use_parentheses_in_expressions=false
+cleanup.use_this_for_non_static_field_access=false
+cleanup.use_this_for_non_static_field_access_only_if_necessary=true
+cleanup.use_this_for_non_static_method_access=false
+cleanup.use_this_for_non_static_method_access_only_if_necessary=true
+cleanup_profile=_empolis
+cleanup_settings_version=2
 eclipse.preferences.version=1
 editor_save_participant_org.eclipse.jdt.ui.postsavelistener.cleanup=true
-formatter_profile=_empolis
+formatter_profile=_Eclipse - Brox
 formatter_settings_version=11
 org.eclipse.jdt.ui.ignorelowercasenames=false
 org.eclipse.jdt.ui.importorder=java;javax;org;com;
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/META-INF/MANIFEST.MF b/tooling/org.eclipse.smila.processing.designer.ui/META-INF/MANIFEST.MF
index bb9a750..8b45739 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/META-INF/MANIFEST.MF
+++ b/tooling/org.eclipse.smila.processing.designer.ui/META-INF/MANIFEST.MF
@@ -3,16 +3,17 @@
 Bundle-Name: GUI for SMILA Pipelets
 Bundle-Vendor: org.eclipse.smila
 Bundle-SymbolicName: org.eclipse.smila.processing.designer.ui;singleton:=true
-Bundle-Version: 0.1.0
+Bundle-Version: 0.8.0
 Bundle-Activator: org.eclipse.smila.processing.designer.ui.Activator
 Require-Bundle: org.eclipse.ui,
  org.eclipse.core.runtime,
  org.eclipse.bpel.common.ui,
- org.eclipse.bpel.ui;bundle-version="0.3.0",
- org.eclipse.gef;bundle-version="3.4.0",
- org.eclipse.emf.ecore;bundle-version="[2.4.0,3.0.0)",
- org.eclipse.smila.processing.designer.model;bundle-version="0.1.0",
- org.eclipse.core.resources;bundle-version="3.4.0",
- org.eclipse.ui.views.properties.tabbed;bundle-version="3.4.0"
+ org.eclipse.bpel.ui,
+ org.eclipse.gef,
+ org.eclipse.emf.ecore,
+ org.eclipse.smila.processing.designer.model,
+ org.eclipse.core.resources,
+ org.eclipse.ui.views.properties.tabbed,
+ org.eclipse.bpel.wsil.model
 Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: JavaSE-1.6
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/about.html b/tooling/org.eclipse.smila.processing.designer.ui/about.html
index 910ad79..d8dfe9d 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/about.html
+++ b/tooling/org.eclipse.smila.processing.designer.ui/about.html
@@ -1,28 +1,28 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
-<title>About</title>
-</head>
-<body lang="EN-US">
-<h2>About This Content</h2>
- 
-<p>Apr 28, 2008</p>	
-<h3>License</h3>
-
-<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
-indicated below, the Content is provided to you under the terms and conditions of the
-Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
-at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
-For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
-
-<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
-being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
-apply to your use of any object code in the Content.  Check the Redistributor's license that was 
-provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
-indicated below, the terms and conditions of the EPL still apply to any source code in the Content
-and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
-
-</body>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>Apr 28, 2008</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
+
+</body>
 </html>
\ No newline at end of file
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/build-plugins.xml b/tooling/org.eclipse.smila.processing.designer.ui/build-plugins.xml
new file mode 100644
index 0000000..6d0909e
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/build-plugins.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project default="plugin_export" name="build">
+	<target name="plugin_export">
+		<pde.exportPlugins destination="." exportSource="false" exportType="zip" filename="plugins.zip" plugins="org.eclipse.smila.processing.designer.model,org.eclipse.smila.processing.designer.ui" useJARFormat="true"/>
+	</target>
+</project>
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/build.properties b/tooling/org.eclipse.smila.processing.designer.ui/build.properties
index f90bb08..3bd0528 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/build.properties
+++ b/tooling/org.eclipse.smila.processing.designer.ui/build.properties
@@ -5,7 +5,8 @@
 # * which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
 # **********************************************************************************************************************/
 source.. = code/src/
-output.. = code/bin/
+output.. = bin/
 bin.includes = META-INF/,\
                .,\
-               plugin.xml
+               plugin.xml,\
+               icons/
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/Activator.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/Activator.java
index 68d3abd..7998c6a 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/Activator.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/Activator.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui;
 
@@ -22,107 +21,96 @@
 
 /**
  * Controls the plug-in life cycle.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class Activator extends AbstractUIPlugin
-{
+public class Activator extends AbstractUIPlugin {
 
-    /** The plug-in ID */
-    public static final String PLUGIN_ID = "org.eclipse.smila.processing.designer.ui";
+  /** The plug-in ID */
+  public static final String PLUGIN_ID = "org.eclipse.smila.processing.designer.ui";
 
-    // Shared instance
-    private static Activator plugin;
+  // Shared instance
+  private static Activator plugin;
 
-    /**
-     * The shared plugin instance.
-     * 
-     * Only available, if the plugin is {@link #start(BundleContext) started}.
-     *
-     * @return the shared instance
-     */
-    public static Activator getDefault()
-    {
-        return plugin;
+  /**
+   * The shared plugin instance.
+   * 
+   * Only available, if the plugin is {@link #start(BundleContext) started}.
+   * 
+   * @return the shared instance
+   */
+  public static Activator getDefault() {
+    return plugin;
+  }
+
+  /**
+   * Creates a new instance of Activator.
+   */
+  public Activator() {
+    // Register processor package
+    BPELUtil.registerAdapterFactory(ProcessorPackage.eINSTANCE, UIAdapterFactory.getInstance());
+
+    // Register record package
+    BPELUtil.registerAdapterFactory(RecordPackage.eINSTANCE, UIAdapterFactory.getInstance());
+  }
+
+  /**
+   * @see AbstractUIPlugin#start(BundleContext)
+   */
+  @Override
+  public void start(BundleContext context) throws Exception {
+    super.start(context);
+    // Register shared instance
+    plugin = this;
+  }
+
+  /**
+   * @see AbstractUIPlugin#stop(BundleContext)
+   */
+  @Override
+  public void stop(BundleContext context) throws Exception {
+    // Forget shared instance.
+    plugin = null;
+    super.stop(context);
+  }
+
+  /**
+   * Initialize plugin icons.
+   * 
+   * @see AbstractUIPlugin#initializeImageRegistry(ImageRegistry)
+   */
+  @Override
+  protected void initializeImageRegistry(ImageRegistry reg) {
+    URL baseURL = getBundle().getEntry("/");
+    createImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_16, baseURL);
+    createImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_20, baseURL);
+    createImageDescriptor(SMILADesignerUIConstants.RECORD_MAP_ICON_16, baseURL);
+    createImageDescriptor(SMILADesignerUIConstants.RECORD_SEQ_ICON_16, baseURL);
+    createImageDescriptor(SMILADesignerUIConstants.RECORD_VAL_ICON_16, baseURL);
+  }
+
+  private void createImageDescriptor(String id, URL baseURL) {
+    URL url = null;
+    try {
+      url = new URL(baseURL, "icons/" + id);
+    } catch (MalformedURLException e) {
+      getLog().log(new Status(IStatus.ERROR, PLUGIN_ID, e.getLocalizedMessage()));
     }
+    ImageDescriptor descriptor = ImageDescriptor.createFromURL(url);
+    getImageRegistry().put(id, descriptor);
+  }
 
-    /**
-     * Creates a new instance of Activator.
-     */
-    public Activator()
-    {
-        // Register processor package
-        BPELUtil.registerAdapterFactory(ProcessorPackage.eINSTANCE, UIAdapterFactory.getInstance());
-
-        // Register record package
-        BPELUtil.registerAdapterFactory(RecordPackage.eINSTANCE, UIAdapterFactory.getInstance());
-    }
-
-    /**
-     * @see AbstractUIPlugin#start(BundleContext)
-     */
-    @Override
-    public void start(BundleContext context) throws Exception
-    {
-        super.start(context);
-        // Register shared instance
-        plugin = this;
-    }
-
-    /**
-     * @see AbstractUIPlugin#stop(BundleContext)
-     */
-    @Override
-    public void stop(BundleContext context) throws Exception
-    {
-        // Forget shared instance.
-        plugin = null;
-        super.stop(context);
-    }
-
-    /**
-     * Initialize plugin icons.
-     * 
-     * @see AbstractUIPlugin#initializeImageRegistry(ImageRegistry)
-     */
-    @Override
-    protected void initializeImageRegistry(ImageRegistry reg)
-    {
-        URL baseURL = getBundle().getEntry("/");
-        createImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_16, baseURL);
-        createImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_20, baseURL);
-        createImageDescriptor(SMILADesignerUIConstants.INVOKE_SERVICE_ICON_16, baseURL);
-        createImageDescriptor(SMILADesignerUIConstants.INVOKE_SERVICE_ICON_20, baseURL);
-        createImageDescriptor(SMILADesignerUIConstants.ANNOTATION_ICON_16, baseURL);
-        createImageDescriptor(SMILADesignerUIConstants.ANNOTATION_VALUE_ICON_16, baseURL);
-    }
-
-    private void createImageDescriptor(String id, URL baseURL)
-    {
-        URL url = null;
-        try
-        {
-            url = new URL(baseURL, "icons/" + id);
-        }
-        catch (MalformedURLException e)
-        {
-            getLog().log(new Status(IStatus.ERROR, PLUGIN_ID, e.getLocalizedMessage()));
-        }
-        ImageDescriptor descriptor = ImageDescriptor.createFromURL(url);
-        getImageRegistry().put(id, descriptor);
-    }
-
-    /**
-     * Resolves the image descriptor for the given id.
-     *
-     * @param id the id (path) of the image
-     * @return the image descriptor or {@code null} if none
-     */
-    public ImageDescriptor getImageDescriptor(String id)
-    {
-        return getImageRegistry().getDescriptor(id);
-    }
+  /**
+   * Resolves the image descriptor for the given id.
+   * 
+   * @param id
+   *          the id (path) of the image
+   * @return the image descriptor or {@code null} if none
+   */
+  public ImageDescriptor getImageDescriptor(String id) {
+    return getImageRegistry().getDescriptor(id);
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/SMILADesignerUIConstants.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/SMILADesignerUIConstants.java
index 45f29e4..b20712e 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/SMILADesignerUIConstants.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/SMILADesignerUIConstants.java
@@ -1,48 +1,41 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui;
 
 /**
  * Constants used in the plugin.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class SMILADesignerUIConstants
-{
+public class SMILADesignerUIConstants {
 
-    /**
-     * ID and path to the 16x16 icon of the activity.
-     */
-    public static final String INVOKE_PIPELET_ICON_16 = "obj16/invokePipelet.gif";
+  /**
+   * ID and path to the 16x16 icon of the activity.
+   */
+  public static final String INVOKE_PIPELET_ICON_16 = "obj16/invokePipelet.png";
 
-    /**
-     * ID and path to the 20x20 icon of the activity.
-     */
-    public static final String INVOKE_PIPELET_ICON_20 = "obj20/invokePipelet.png";
+  /**
+   * ID and path to the 20x20 icon of the activity.
+   */
+  public static final String INVOKE_PIPELET_ICON_20 = "obj20/invokePipelet.png";
 
-    /**
-     * ID and path to the 16x16 icon of the activity.
-     */
-    public static final String INVOKE_SERVICE_ICON_16 = "obj16/invokeService.gif";
+  /**
+   * ID and path to the 16x16 icon of the Record Map.
+   */
+  public static final String RECORD_MAP_ICON_16 = "obj16/icon_map.png";
 
-    /**
-     * ID and path to the 20x20 icon of the activity.
-     */
-    public static final String INVOKE_SERVICE_ICON_20 = "obj20/invokeService.png";
+  /**
+   * ID and path to the 16x16 icon of the Record Sequence.
+   */
+  public static final String RECORD_SEQ_ICON_16 = "obj16/icon_seq.png";
 
-    /**
-     * ID and path to the 16x16 icon of the annotation.
-     */
-    public static final String ANNOTATION_ICON_16 = "obj16/bulletBlack.png";
-
-    /**
-     * ID and path to the 16x16 icon of the annotation value.
-     */
-    public static final String ANNOTATION_VALUE_ICON_16 = "obj16/bulletBlue.png";
+  /**
+   * ID and path to the 16x16 icon of the Record Value.
+   */
+  public static final String RECORD_VAL_ICON_16 = "obj16/icon_val.png";
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokePipeletAdapter.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokePipeletAdapter.java
index 198e71a..3031584 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokePipeletAdapter.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokePipeletAdapter.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.adapters;
 
@@ -12,49 +11,45 @@
 
 /**
  * Adapter for {@link org.eclipse.smila.processing.designer.model.processor.InvokePipelet} instances.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class InvokePipeletAdapter extends ActivityAdapter
-{
+public class InvokePipeletAdapter extends ActivityAdapter {
 
-    /**
-     * The name of the wrapped piplet class.
-     * 
-     * @param modelObject the {@link InvokePipelet} or {@link Pipelet}.
-     *
-     * @return the pipelet class name or {@code null} if none is set up to now
-     */
-    public String getClassName(Object modelObject)
-    {
-        if (modelObject instanceof InvokePipelet)
-        {
-            modelObject = ((InvokePipelet) modelObject).getPipelet();
-        }
-        if (modelObject instanceof Pipelet)
-        {
-            return ((Pipelet) modelObject).getClass_();
-        }
-        return null;
+  /**
+   * The name of the wrapped piplet class.
+   * 
+   * @param modelObject
+   *          the {@link InvokePipelet} or {@link Pipelet}.
+   * 
+   * @return the pipelet class name or {@code null} if none is set up to now
+   */
+  public String getClassName(Object modelObject) {
+    if (modelObject instanceof InvokePipelet) {
+      modelObject = ((InvokePipelet) modelObject).getPipelet();
     }
+    if (modelObject instanceof Pipelet) {
+      return ((Pipelet) modelObject).getClass_();
+    }
+    return null;
+  }
 
-    /**
-     * Sets the name of the wrapped piplet class.
-     * 
-     * @param modelObject the {@link InvokePipelet} or {@link Pipelet}.
-     * @param className the new pipelet class name 
-     */
-    public void setClassName(Object modelObject, String className)
-    {
-        if (modelObject instanceof InvokePipelet)
-        {
-            modelObject = ((InvokePipelet) modelObject).getPipelet();
-        }
-        if (modelObject instanceof Pipelet)
-        {
-            ((Pipelet) modelObject).setClass(className);
-        }
+  /**
+   * Sets the name of the wrapped piplet class.
+   * 
+   * @param modelObject
+   *          the {@link InvokePipelet} or {@link Pipelet}.
+   * @param className
+   *          the new pipelet class name
+   */
+  public void setClassName(Object modelObject, String className) {
+    if (modelObject instanceof InvokePipelet) {
+      modelObject = ((InvokePipelet) modelObject).getPipelet();
     }
+    if (modelObject instanceof Pipelet) {
+      ((Pipelet) modelObject).setClass(className);
+    }
+  }
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokeServiceAdapter.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokeServiceAdapter.java
index 92ed65f..4d3b008 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokeServiceAdapter.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/adapters/InvokeServiceAdapter.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.adapters;
 
@@ -10,12 +9,11 @@
 
 /**
  * Adapter for {@link org.eclipse.smila.processing.designer.model.processor.InvokeService} instances.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class InvokeServiceAdapter extends ActivityAdapter
-{
-    // Tagging class for now
+public class InvokeServiceAdapter extends ActivityAdapter {
+  // Tagging class for now
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/commands/AddToListFeatureCommand.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/commands/AddToListFeatureCommand.java
new file mode 100644
index 0000000..4e9725d
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/commands/AddToListFeatureCommand.java
@@ -0,0 +1,59 @@
+/***********************************************************************************************************************
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ **********************************************************************************************************************/
+package org.eclipse.smila.processing.designer.ui.commands;
+
+import java.util.List;
+
+import org.eclipse.bpel.ui.commands.AddToListCommand;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+
+/**
+ * Adds a new value to a {@link List} attribute of an {@link EObject}.
+ * 
+ * Copyright (c) 2011 Attensity Europe GmbH
+ * 
+ * @author Tobias Liefke
+ */
+public class AddToListFeatureCommand extends AddToListCommand {
+  private final EStructuralFeature feature;
+
+  /**
+   * Creates a new instance of AddToListFeatureCommand.
+   * 
+   * @param target
+   *          the object that contains the list to modify
+   * @param newElement
+   *          the new element to add to the list
+   * @param feature
+   *          the id of the list attribute
+   */
+  public AddToListFeatureCommand(EObject target, Object newElement, EStructuralFeature feature) {
+    this(target, newElement, feature, "Add value");
+  }
+
+  /**
+   * Creates a new instance of RemoveFromListFeatureCommand.
+   * 
+   * @param target
+   *          the object that contains the list to modify
+   * @param newElement
+   *          the new element to add to the list
+   * @param feature
+   *          the id of the list attribute
+   * @param label
+   *          the label of the command (for undo)
+   */
+  public AddToListFeatureCommand(EObject target, Object newElement, EStructuralFeature feature, String label) {
+    super(target, newElement, label);
+    this.feature = feature;
+  }
+
+  @Override
+  protected List<?> getList() {
+    return (List<?>) target.eGet(feature);
+  }
+}
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/commands/RemoveFromListFeatureCommand.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/commands/RemoveFromListFeatureCommand.java
new file mode 100644
index 0000000..6f7e28d
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/commands/RemoveFromListFeatureCommand.java
@@ -0,0 +1,71 @@
+/***********************************************************************************************************************
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
+ **********************************************************************************************************************/
+package org.eclipse.smila.processing.designer.ui.commands;
+
+import java.util.List;
+
+import org.eclipse.bpel.ui.commands.RemoveFromListCommand;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.smila.processing.designer.model.record.RecordValues;
+
+/**
+ * Removes a value from a {@link RecordValues} object.
+ * 
+ * Copyright (c) 2011 Attensity Europe GmbH
+ * 
+ * @author Tobias Liefke
+ */
+public class RemoveFromListFeatureCommand extends RemoveFromListCommand {
+
+  private final EStructuralFeature feature;
+
+  /**
+   * Creates a new instance of RemoveFromListFeatureCommand.
+   * 
+   * @param oldElement
+   *          the element to remove from its container
+   */
+  public RemoveFromListFeatureCommand(EObject oldElement) {
+    this(oldElement.eContainer(), oldElement, oldElement.eContainingFeature(), "Remove value");
+  }
+
+  /**
+   * Creates a new instance of RemoveFromListFeatureCommand.
+   * 
+   * @param target
+   *          the object that contains the list to modify
+   * @param oldElement
+   *          the element to remve from the list
+   * @param feature
+   *          the id of the list attribute
+   */
+  public RemoveFromListFeatureCommand(EObject target, Object oldElement, EStructuralFeature feature) {
+    this(target, oldElement, feature, "Remove value");
+  }
+
+  /**
+   * Creates a new instance of RemoveFromListFeatureCommand.
+   * 
+   * @param target
+   *          the object that contains the list to modify
+   * @param oldElement
+   *          the element to remve from the list
+   * @param feature
+   *          the id of the list attribute
+   * @param label
+   *          the label of the command (for undo)
+   */
+  public RemoveFromListFeatureCommand(EObject target, Object oldElement, EStructuralFeature feature, String label) {
+    super(target, oldElement, label);
+    this.feature = feature;
+  }
+
+  @Override
+  protected List<?> getList() {
+    return (List<?>) target.eGet(feature);
+  }
+}
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokePipeletUIFactory.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokePipeletUIFactory.java
index 831f6e8..371ea7f 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokePipeletUIFactory.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokePipeletUIFactory.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.factories;
 
@@ -11,103 +10,94 @@
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.smila.processing.designer.model.processor.InvokePipelet;
-import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
+import org.eclipse.smila.processing.designer.model.processor.*;
 import org.eclipse.smila.processing.designer.ui.Activator;
 import org.eclipse.smila.processing.designer.ui.SMILADesignerUIConstants;
 import org.eclipse.swt.graphics.Image;
 
 /**
  * Offers the UI objects for the "invoke pipelet" activity.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class InvokePipeletUIFactory extends AbstractUIObjectFactory implements IExtensionUIObjectFactory
-{
-    private EClass modelType;
-    private EClass[] classArray = {ProcessorPackage.eINSTANCE.getInvokePipelet()};
+public class InvokePipeletUIFactory extends AbstractUIObjectFactory implements IExtensionUIObjectFactory {
+  private EClass modelType;
 
-    /**
-     * Creates a new instance of InvokePipeletUIFactory.
-     */
-    public InvokePipeletUIFactory()
-    {
-        // Empty constructor
-    }
+  private EClass[] classArray = { ProcessorPackage.eINSTANCE.getInvokePipelet() };
 
-    /**
-     * Creates a new instance of InvokePipeletUIFactory for the given class.
-     * 
-     * @param modelType
-     */
-    public InvokePipeletUIFactory(EClass modelType)
-    {
-        this.modelType = modelType;
-    }
+  /**
+   * Creates a new instance of InvokePipeletUIFactory.
+   */
+  public InvokePipeletUIFactory() {
+    // Empty constructor
+  }
 
-    @Override
-    public Image getLargeImage()
-    {
-        return Activator.getDefault().getImageRegistry().get(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_20);
-    }
+  /**
+   * Creates a new instance of InvokePipeletUIFactory for the given class.
+   * 
+   * @param modelType
+   */
+  public InvokePipeletUIFactory(EClass modelType) {
+    this.modelType = modelType;
+  }
 
-    @Override
-    public ImageDescriptor getLargeImageDescriptor()
-    {
-        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_20);
-    }
+  @Override
+  public Image getLargeImage() {
+    return Activator.getDefault().getImageRegistry().get(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_20);
+  }
 
-    @Override
-    public EClass getModelType()
-    {
-        return this.modelType;
-    }
+  @Override
+  public ImageDescriptor getLargeImageDescriptor() {
+    return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_20);
+  }
 
-    @Override
-    public Image getSmallImage()
-    {
-        return Activator.getDefault().getImageRegistry().get(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_16);
-    }
+  @Override
+  public EClass getModelType() {
+    return this.modelType;
+  }
 
-    @Override
-    public ImageDescriptor getSmallImageDescriptor()
-    {
-        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_16);
-    }
+  @Override
+  public Image getSmallImage() {
+    return Activator.getDefault().getImageRegistry().get(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_16);
+  }
 
-    @Override
-    public String getTypeLabel()
-    {
-        return getModelType().getName();
-    }
+  @Override
+  public ImageDescriptor getSmallImageDescriptor() {
+    return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.INVOKE_PIPELET_ICON_16);
+  }
 
-    @Override
-    public EClass[] getClassArray()
-    {
-        return this.classArray;
-    }
+  @Override
+  public String getTypeLabel() {
+    return getModelType().getName();
+  }
 
-    @Override
-    public void setModelType(EClass modelType)
-    {
-        this.modelType = modelType;
-    }
+  @Override
+  public EClass[] getClassArray() {
+    return this.classArray;
+  }
 
-    /**
-     * Initialize created objects.
-     * 
-     * @see org.eclipse.bpel.ui.factories.AbstractUIObjectFactory#createInstance()
-     */
-    @Override
-    public <T extends EObject> T createInstance()
-    {
-        T instance = super.createInstance();
-        InvokePipelet pipelet = (InvokePipelet) instance;
-        pipelet.getVariables().setInput("request");
-        pipelet.getVariables().setOutput("request");
-        return instance;
-    }
+  @Override
+  public void setModelType(EClass modelType) {
+    this.modelType = modelType;
+  }
+
+  /**
+   * Initialize created objects.
+   * 
+   * @see org.eclipse.bpel.ui.factories.AbstractUIObjectFactory#createInstance()
+   */
+  @Override
+  public <T extends EObject> T createInstance() {
+    T instance = super.createInstance();
+    InvokePipelet pipelet = (InvokePipelet) instance;
+    pipelet.setPipelet(ProcessorFactory.eINSTANCE.createPipelet());
+    pipelet.setVariables(ProcessorFactory.eINSTANCE.createVariables());
+    pipelet.getVariables().setInput("request");
+    pipelet.getVariables().setOutput("request");
+    pipelet.setConfiguration(ProcessorFactory.eINSTANCE.createConfiguration());
+    return instance;
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokeServiceUIFactory.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokeServiceUIFactory.java
deleted file mode 100644
index 838b2ad..0000000
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/InvokeServiceUIFactory.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.ui.factories;
-
-import org.eclipse.bpel.ui.factories.AbstractUIObjectFactory;
-import org.eclipse.bpel.ui.factories.IExtensionUIObjectFactory;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.jface.resource.ImageDescriptor;
-import org.eclipse.smila.processing.designer.model.processor.InvokeService;
-import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
-import org.eclipse.smila.processing.designer.ui.Activator;
-import org.eclipse.smila.processing.designer.ui.SMILADesignerUIConstants;
-import org.eclipse.swt.graphics.Image;
-
-/**
- * Offers the UI objects for the "invoke service" activity.
- *
- * Copyright (c) 2010 Attensity Europe GmbH
- *
- * @author Tobias Liefke
- */
-public class InvokeServiceUIFactory extends AbstractUIObjectFactory implements IExtensionUIObjectFactory
-{
-    private EClass modelType;
-    private EClass[] classArray = {ProcessorPackage.eINSTANCE.getInvokeService()};
-
-    /**
-     * Creates a new instance of InvokePipeletUIFactory.
-     */
-    public InvokeServiceUIFactory()
-    {
-        // Empty constructor
-    }
-
-    /**
-     * Creates a new instance of InvokePipeletUIFactory for the given class.
-     * 
-     * @param modelType
-     */
-    public InvokeServiceUIFactory(EClass modelType)
-    {
-        this.modelType = modelType;
-    }
-
-    @Override
-    public Image getLargeImage()
-    {
-        return Activator.getDefault().getImageRegistry().get(SMILADesignerUIConstants.INVOKE_SERVICE_ICON_20);
-    }
-
-    @Override
-    public ImageDescriptor getLargeImageDescriptor()
-    {
-        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.INVOKE_SERVICE_ICON_20);
-    }
-
-    @Override
-    public EClass getModelType()
-    {
-        return this.modelType;
-    }
-
-    @Override
-    public Image getSmallImage()
-    {
-        return Activator.getDefault().getImageRegistry().get(SMILADesignerUIConstants.INVOKE_SERVICE_ICON_16);
-    }
-
-    @Override
-    public ImageDescriptor getSmallImageDescriptor()
-    {
-        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.INVOKE_SERVICE_ICON_16);
-    }
-
-    @Override
-    public String getTypeLabel()
-    {
-        return getModelType().getName();
-    }
-
-    @Override
-    public EClass[] getClassArray()
-    {
-        return this.classArray;
-    }
-
-    @Override
-    public void setModelType(EClass modelType)
-    {
-        this.modelType = modelType;
-    }
-
-    /**
-     * Initialize created objects.
-     * 
-     * @see org.eclipse.bpel.ui.factories.AbstractUIObjectFactory#createInstance()
-     */
-    @Override
-    public <T extends EObject> T createInstance()
-    {
-        T instance = super.createInstance();
-        InvokeService service = (InvokeService) instance;
-        service.getVariables().setInput("request");
-        service.getVariables().setOutput("request");
-        return instance;
-    }
-
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/UIAdapterFactory.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/UIAdapterFactory.java
index 14c8b93..515d1fe 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/UIAdapterFactory.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/factories/UIAdapterFactory.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.factories;
 
@@ -13,63 +12,46 @@
 
 /**
  * Used to create adapters of the EMF model.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class UIAdapterFactory extends ProcessorAdapterFactory
-{
-    private static UIAdapterFactory instance;
-    private InvokePipeletAdapter invokePipeletAdapter;
-    private InvokeServiceAdapter invokeServiceAdapter;
+public class UIAdapterFactory extends ProcessorAdapterFactory {
+  private static UIAdapterFactory instance;
 
-    /**
-     * Resolves the singleton instance of this factory.
-     *
-     * @return the singleton instance
-     */
-    public static UIAdapterFactory getInstance()
-    {
-        if (instance == null)
-        {
-            instance = new UIAdapterFactory();
-        }
-        return instance;
-    }
+  private InvokePipeletAdapter invokePipeletAdapter;
 
-    /**
-     * Private constructor, as we are singleton.
-     */
-    private UIAdapterFactory()
-    {
-        super();
-    }
+  private InvokeServiceAdapter invokeServiceAdapter;
 
-    /**
-     * @see ProcessorAdapterFactory#createInvokePipeletAdapter()
-     */
-    @Override
-    public Adapter createInvokePipeletAdapter()
-    {
-        if (invokePipeletAdapter == null)
-        {
-            invokePipeletAdapter = new InvokePipeletAdapter();
-        }
-        return invokePipeletAdapter;
+  /**
+   * Resolves the singleton instance of this factory.
+   * 
+   * @return the singleton instance
+   */
+  public static UIAdapterFactory getInstance() {
+    if (instance == null) {
+      instance = new UIAdapterFactory();
     }
+    return instance;
+  }
 
-    /**
-     * @see ProcessorAdapterFactory#createInvokeServiceAdapter()
-     */
-    @Override
-    public Adapter createInvokeServiceAdapter()
-    {
-        if (invokeServiceAdapter == null)
-        {
-            invokeServiceAdapter = new InvokeServiceAdapter();
-        }
-        return invokeServiceAdapter;
+  /**
+   * Private constructor, as we are singleton.
+   */
+  private UIAdapterFactory() {
+    super();
+  }
+
+  /**
+   * @see ProcessorAdapterFactory#createInvokePipeletAdapter()
+   */
+  @Override
+  public Adapter createInvokePipeletAdapter() {
+    if (invokePipeletAdapter == null) {
+      invokePipeletAdapter = new InvokePipeletAdapter();
     }
+    return invokePipeletAdapter;
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/palette/SMILADesignerPaletteProvider.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/palette/SMILADesignerPaletteProvider.java
index 1dfbf79..53df750 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/palette/SMILADesignerPaletteProvider.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/palette/SMILADesignerPaletteProvider.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.palette;
 
@@ -12,34 +11,29 @@
 import org.eclipse.gef.palette.PaletteRoot;
 import org.eclipse.smila.processing.designer.model.processor.ProcessorPackage;
 import org.eclipse.smila.processing.designer.ui.factories.InvokePipeletUIFactory;
-import org.eclipse.smila.processing.designer.ui.factories.InvokeServiceUIFactory;
 
 /**
  * Responsible for extendening the BPEL palette with SMILA items.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class SMILADesignerPaletteProvider implements IPaletteProvider
-{
+public class SMILADesignerPaletteProvider implements IPaletteProvider {
 
-    /**
-     * @see IPaletteProvider#contributeItems(PaletteRoot)
-     */
-    @Override
-    public void contributeItems(PaletteRoot paletteRoot)
-    {
-        PaletteCategory category = new PaletteCategory("SMILA");
-        category.setCategoryId("org.eclipse.smila");
-        category.setOrder(40);
+  /**
+   * @see IPaletteProvider#contributeItems(PaletteRoot)
+   */
+  @Override
+  public void contributeItems(PaletteRoot paletteRoot) {
+    PaletteCategory category = new PaletteCategory("SMILA");
+    category.setCategoryId("org.eclipse.smila");
+    category.setOrder(40);
 
-        category.add(new BPELCreationToolEntry("Pipelet", "Invokes a SMILA pipelet", new InvokePipeletUIFactory(
-                ProcessorPackage.eINSTANCE.getInvokePipelet())));
-        category.add(new BPELCreationToolEntry("Service", "Invokes a SMILA service", new InvokeServiceUIFactory(
-                ProcessorPackage.eINSTANCE.getInvokeService())));
+    category.add(new BPELCreationToolEntry("Pipelet", "Invokes a SMILA pipelet", new InvokePipeletUIFactory(
+      ProcessorPackage.eINSTANCE.getInvokePipelet())));
 
-        paletteRoot.add(category);
-    }
+    paletteRoot.add(category);
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationProvider.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationProvider.java
index f976a09..f9d1db6 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationProvider.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationProvider.java
@@ -1,41 +1,36 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.properties;
 
 import java.util.List;
 
 import org.eclipse.bpel.ui.details.providers.AbstractContentProvider;
-import org.eclipse.smila.processing.designer.model.processor.PipeletConfiguration;
+import org.eclipse.smila.processing.designer.model.processor.Configuration;
 
-/** 
+/**
  * Offers the entries of the pipelet configuration table.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class PipeletConfigurationProvider extends AbstractContentProvider
-{
+public class PipeletConfigurationProvider extends AbstractContentProvider {
 
-    /**
-     * @see AbstractContentProvider#collectElements(Object, List)
-     */
-    @Override
-    public void collectElements(Object input, List<Object> list)
-    {
-        if (input instanceof PipeletConfiguration)
-        {
-            PipeletConfiguration configuration = (PipeletConfiguration) input;
-            if (configuration != null)
-            {
-                list.addAll(configuration.getProperties());
-            }
-            list.add("");
-        }
+  /**
+   * @see AbstractContentProvider#collectElements(Object, List)
+   */
+  @Override
+  public void collectElements(Object input, List<Object> list) {
+    if (input instanceof Configuration) {
+      Configuration configuration = (Configuration) input;
+      if (configuration != null) {
+        list.addAll(configuration.getValues());
+      }
+      list.add("");
     }
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationSection.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationSection.java
index 83d6ff2..dd630dc 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationSection.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletConfigurationSection.java
@@ -1,407 +1,697 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.properties;
 
+import java.text.MessageFormat;
+import java.text.ParseException;
+import java.util.ArrayList;
 import java.util.List;
 
-import org.eclipse.bpel.ui.commands.*;
-import org.eclipse.bpel.ui.details.providers.ColumnTableProvider;
+import org.eclipse.bpel.ui.commands.SetCommand;
 import org.eclipse.bpel.ui.properties.BPELPropertySection;
 import org.eclipse.bpel.ui.util.MultiObjectAdapter;
 import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EContentAdapter;
+import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.viewers.*;
-import org.eclipse.smila.processing.designer.model.processor.*;
+import org.eclipse.smila.processing.designer.model.processor.Configuration;
+import org.eclipse.smila.processing.designer.model.processor.InvokePipelet;
+import org.eclipse.smila.processing.designer.model.record.*;
+import org.eclipse.smila.processing.designer.ui.Activator;
+import org.eclipse.smila.processing.designer.ui.SMILADesignerUIConstants;
+import org.eclipse.smila.processing.designer.ui.commands.AddToListFeatureCommand;
+import org.eclipse.smila.processing.designer.ui.commands.RemoveFromListFeatureCommand;
 import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.CCombo;
 import org.eclipse.swt.events.*;
-import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.*;
 
 /**
  * Show the configuration options of a pipelet.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
- * @author Tobias Liefke
+ * 
+ * @author Lars Kunze
  */
-public class PipeletConfigurationSection extends BPELPropertySection
-{
-    private Table propertiesTable;
-    private TableViewer propertiesViewer;
-    private ColumnTableProvider tableProvider;
-    private EContentAdapter adapter = new EContentAdapter()
-    {
-        /**
-         * @see EContentAdapter#notifyChanged(Notification)
-         */
-        @Override
-        public void notifyChanged(Notification notification)
-        {
-            super.notifyChanged(notification);
-            if (notification.getEventType() != Notification.REMOVING_ADAPTER)
-            {
-                propertiesViewer.setInput(getInput());
-            }
+public class PipeletConfigurationSection extends BPELPropertySection {
+  private static final String LABEL_COLUMN_KEY = "Key";
+
+  private static final String LABEL_COLUMN_VALUE = "Value";
+
+  private static final String LABEL_COLUMN_TYPE = "Type";
+
+  private static final String LABEL_MENU_ITEM_ADD_MAP = "Add Map";
+
+  private static final String LABEL_MENU_ITEM_ADD_SEQ = "Add Sequence";
+
+  private static final String LABEL_MENU_ITEM_ADD_VAL = "Add Value";
+
+  private static final String LABEL_MENU_ITEM_DELETE = "Delete";
+
+  private Composite compositeTree;
+
+  private TreeViewer treeViewer;
+
+  private EContentAdapter adapter = new EContentAdapter() {
+    /**
+     * @see EContentAdapter#notifyChanged(Notification)
+     */
+    @Override
+    public void notifyChanged(Notification notification) {
+      super.notifyChanged(notification);
+      if (notification.getEventType() != Notification.REMOVING_ADAPTER) {
+        treeViewer.setInput(getInput());
+      }
+    }
+  };
+
+  // ### Override/implement methods ###
+
+  /**
+   * @see BPELPropertySection#shouldUseExtraSpace()
+   */
+  @Override
+  public boolean shouldUseExtraSpace() {
+    return true;
+  }
+
+  /**
+   * @see BPELPropertySection#createAdapters()
+   */
+  @Override
+  protected MultiObjectAdapter[] createAdapters() {
+    return new MultiObjectAdapter[] { new MultiObjectAdapter() {
+      @Override
+      public void notify(Notification n) {
+        treeViewer.setInput(getInput());
+      }
+    } };
+  }
+
+  /**
+   * Add the listeners.
+   * 
+   * @see properties.BPELPropertySection#addAllAdapters()
+   */
+  @Override
+  protected void addAllAdapters() {
+    super.addAllAdapters();
+    Configuration configuration = getInput();
+    if (configuration != null) {
+      configuration.eAdapters().add(adapter);
+    }
+  }
+
+  /**
+   * Remove the listeners.
+   * 
+   * @see BPELPropertySection#removeAllAdapters()
+   */
+  @Override
+  protected void removeAllAdapters() {
+    Configuration configuration = getInput();
+    if (configuration != null) {
+      configuration.eAdapters().remove(adapter);
+    }
+    super.removeAllAdapters();
+  }
+
+  /**
+   * @see BPELPropertySection#basicSetInput(EObject)
+   */
+  @Override
+  protected void basicSetInput(EObject newInput) {
+    super.basicSetInput(newInput == null ? null : ((InvokePipelet) newInput).getConfiguration());
+
+    if (getInput() != null) {
+      treeViewer.setInput(getInput());
+    }
+  }
+
+  /**
+   * @see BPELPropertySection#createClient()
+   */
+  @Override
+  protected void createClient(Composite parent) {
+    createComponents(parent);
+  }
+
+  // ### Utility methods ###
+
+  private Configuration getConfiguration() {
+    return getInput();
+  }
+
+  /**
+   * Creates the components of this section.
+   * 
+   * @param parent
+   */
+  private void createComponents(Composite parent) {
+    parent.setLayout(new GridLayout(1, false));
+
+    // (1) Tree
+    compositeTree = new Composite(parent, SWT.NONE);
+    compositeTree.setLayout(new GridLayout(1, false));
+    compositeTree.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+    treeViewer = new TreeViewer(compositeTree, SWT.FULL_SELECTION);
+    treeViewer.setContentProvider(new TreeViewerContentProvider());
+    treeViewer.getTree().setHeaderVisible(true);
+    treeViewer.getTree().setLinesVisible(true);
+    treeViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
+    treeViewer.setAutoExpandLevel(3);
+
+    // (2) TreeColumns
+    TreeViewerColumn treeViewerColumnKey = new TreeViewerColumn(treeViewer, SWT.NONE);
+    treeViewerColumnKey.getColumn().setText(LABEL_COLUMN_KEY);
+    treeViewerColumnKey.getColumn().setWidth(200);
+    treeViewerColumnKey.setLabelProvider(new ColumnLabelProviderColKey());
+    treeViewerColumnKey.setEditingSupport(new EditingSupportColKey(treeViewer));
+
+    TreeViewerColumn treeViewerColumnValue = new TreeViewerColumn(treeViewer, SWT.NONE);
+    treeViewerColumnValue.getColumn().setText(LABEL_COLUMN_VALUE);
+    treeViewerColumnValue.getColumn().setWidth(200);
+    treeViewerColumnValue.setLabelProvider(new ColumnLabelProviderColValue());
+    treeViewerColumnValue.setEditingSupport(new EditingSupportColValue(treeViewer));
+
+    TreeViewerColumn treeViewerColumnType = new TreeViewerColumn(treeViewer, SWT.NONE);
+    treeViewerColumnType.getColumn().setText(LABEL_COLUMN_TYPE);
+    treeViewerColumnType.getColumn().setWidth(200);
+    treeViewerColumnType.setLabelProvider(new ColumnLabelProviderColType());
+    treeViewerColumnType.setEditingSupport(new EditingSupportColType(treeViewer));
+
+    // (3) ColumnViewerEditor
+    TreeViewerEditor.create(treeViewer, new TreeViewerColumnViewerEditorActivationStrategy(treeViewer),
+      ColumnViewerEditor.KEYBOARD_ACTIVATION);
+
+    // (4) TreeMenu
+    Menu menuTree = new Menu(parent);
+    final MenuItem menuItemAddMap = new MenuItem(menuTree, SWT.PUSH);
+    menuItemAddMap.setText(LABEL_MENU_ITEM_ADD_MAP);
+    menuItemAddMap.setImage(Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.RECORD_MAP_ICON_16)
+      .createImage());
+    menuItemAddMap.addSelectionListener(new CreateValueMenuAction(RecordPackage.eINSTANCE.getRecordMap()));
+
+    final MenuItem menuItemAddSeq = new MenuItem(menuTree, SWT.PUSH);
+    menuItemAddSeq.setText(LABEL_MENU_ITEM_ADD_SEQ);
+    menuItemAddSeq.setImage(Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.RECORD_SEQ_ICON_16)
+      .createImage());
+    menuItemAddSeq.addSelectionListener(new CreateValueMenuAction(RecordPackage.eINSTANCE.getRecordSeq()));
+
+    final MenuItem menuItemAddVal = new MenuItem(menuTree, SWT.PUSH);
+    menuItemAddVal.setText(LABEL_MENU_ITEM_ADD_VAL);
+    menuItemAddVal.setImage(Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.RECORD_VAL_ICON_16)
+      .createImage());
+    menuItemAddVal.addSelectionListener(new CreateValueMenuAction(RecordPackage.eINSTANCE.getRecordVal()));
+
+    final MenuItem menuItemDelete = new MenuItem(menuTree, SWT.PUSH);
+    menuItemDelete.setText(LABEL_MENU_ITEM_DELETE);
+    menuItemDelete.addSelectionListener(new SelectionAdapter() {
+      @Override
+      public void widgetSelected(SelectionEvent e) {
+        if (treeViewer.getTree().getSelectionCount() > 0) {
+          getCommandFramework().execute(
+            wrapInShowContextCommand(new RemoveFromListFeatureCommand((RecordAny) treeViewer.getTree()
+              .getSelection()[0].getData())));
         }
-    };
+      }
+    });
 
+    treeViewer.getTree().setMenu(menuTree);
+    treeViewer.getTree().addMenuDetectListener(new MenuDetectListener() {
+
+      @Override
+      public void menuDetected(MenuDetectEvent e) {
+        TreeItem treeItem = treeViewer.getTree().getItem(treeViewer.getTree().toControl(e.x, e.y));
+        if (treeItem != null) {
+          treeViewer.getTree().select(treeItem);
+        } else {
+          treeViewer.getTree().deselectAll();
+        }
+        menuItemDelete.setEnabled(treeItem != null);
+      }
+    });
+
+  }
+
+  // ### Inner classes ###
+
+  /**
+   * Implementation of the ITreeContentProvider interface for the treeViewer.
+   */
+  private class TreeViewerContentProvider implements ITreeContentProvider {
     /**
-     * @see BPELPropertySection#createAdapters()
+     * @see ITreeContentProvider#dispose()
      */
     @Override
-    protected MultiObjectAdapter[] createAdapters()
-    {
-        return new MultiObjectAdapter[] {new MultiObjectAdapter()
-        {
-            @Override
-            public void notify(Notification n)
-            {
-                propertiesViewer.setInput(getInput());
-            }
-        }};
+    public void dispose() {
+      // Nothing to do
     }
 
     /**
-     * Make this section use all the vertical space it can get.
+     * @see ITreeContentProvider#inputChanged(Viewer, Object, Object)
      */
     @Override
-    public boolean shouldUseExtraSpace()
-    {
-        return true;
+    public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+      // Nothing to do
     }
 
     /**
-     * Add the listeners.
+     * @see ITreeContentProvider#getElements(Object)
+     */
+    @Override
+    public Object[] getElements(Object inputElement) {
+      return getChildren(inputElement);
+    }
+
+    /**
+     * @see ITreeContentProvider#getChildren(Object)
+     */
+    @Override
+    public Object[] getChildren(Object parentElement) {
+      if (parentElement != null) {
+        if (parentElement instanceof RecordValues) {
+          return ((RecordValues) parentElement).getValues().toArray();
+        }
+        return new Object[0];
+      }
+      return null;
+    }
+
+    /**
+     * @see ITreeContentProvider#getParent
+     */
+    @Override
+    public Object getParent(Object element) {
+      if (element instanceof RecordAny && !(element instanceof Configuration)) {
+        return ((RecordAny) element).getContainer();
+      }
+      return null;
+    }
+
+    /**
+     * @see ITreeContentProvider#hasChildren
+     */
+    @Override
+    public boolean hasChildren(Object element) {
+      return getChildren(element).length > 0;
+    }
+  }
+
+  /**
+   * ColumnLabelProvider for the column "key" of the treeViewer.
+   */
+  private class ColumnLabelProviderColKey extends ColumnLabelProvider {
+    /**
+     * @see ColumnLabelProvider#getImage(Object)
+     */
+    @Override
+    public Image getImage(Object element) {
+      if (element instanceof RecordMap) {
+        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.RECORD_MAP_ICON_16).createImage();
+      } else if (element instanceof RecordSeq) {
+        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.RECORD_SEQ_ICON_16).createImage();
+      } else if (element instanceof RecordVal) {
+        return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.RECORD_VAL_ICON_16).createImage();
+      } else {
+        return null;
+      }
+    }
+
+    /**
+     * @see ColumnLabelProvider#getText(Object)
+     */
+    @Override
+    public String getText(Object element) {
+      if (element instanceof RecordAny) {
+        return ((RecordAny) element).getKey();
+      } else {
+        return null;
+      }
+    }
+  }
+
+  /**
+   * ColumnLabelProvider for the column "value" of the treeViewer.
+   */
+  private class ColumnLabelProviderColValue extends ColumnLabelProvider {
+    /**
+     * @see ColumnLabelProvider#getImage(Object)
+     */
+    @Override
+    public Image getImage(Object element) {
+      return null;
+    }
+
+    /**
+     * @see ColumnLabelProvider#getText(Object)
+     */
+    @Override
+    public String getText(Object element) {
+      if (element instanceof RecordVal) {
+        RecordVal recordVal = ((RecordVal) element);
+        return recordVal != null && recordVal.getValue() != null ? recordVal.getType().format(recordVal.getValue())
+          : "";
+      }
+      return null;
+    }
+  }
+
+  /**
+   * ColumnLabelProvider for the column "type" of the treeViewer.
+   */
+  class ColumnLabelProviderColType extends ColumnLabelProvider {
+    /**
+     * @see ColumnLabelProvider#getImage(Object)
+     */
+    @Override
+    public Image getImage(Object element) {
+      return null;
+    }
+
+    /**
+     * @see ColumnLabelProvider#getText(Object)
+     */
+    @Override
+    public String getText(Object element) {
+      if (((RecordAny) element).isVal()) {
+        RecordVal recordVal = (RecordVal) element;
+        if (recordVal.getType() != null) {
+          return recordVal.getType().name();
+        } else {
+          return RecordVal.Type.STRING.name();
+        }
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Abstract extension of the the class EditingSupport.
+   */
+  private abstract class CellEditingSupport extends EditingSupport {
+    private final CellEditor cellEditor;
+
+    /**
+     * Creates a new instance of CellEditingSupport.
      * 
-     * @see properties.BPELPropertySection#addAllAdapters()
+     * @param viewer
+     *          The viewer for which columns the EditorSupport should be enabled
      */
-    @Override
-    protected void addAllAdapters()
-    {
-        super.addAllAdapters();
-        PipeletConfiguration configuration = getInput();
-        if (configuration != null)
-        {
-            adapter.setTarget(configuration);
-            configuration.eAdapters().add(adapter);
-        }
+    public CellEditingSupport(TreeViewer viewer) {
+      super(viewer);
+      this.cellEditor = new TextCellEditor(viewer.getTree());
     }
 
     /**
-     * Remove the listeners.
-     * 
-     * @see BPELPropertySection#removeAllAdapters()
+     * @see EditingSupport#canEdit(Object)
      */
     @Override
-    protected void removeAllAdapters()
-    {
-        PipeletConfiguration configuration = getInput();
-        if (configuration != null)
-        {
-            configuration.eAdapters().remove(adapter);
-            adapter.unsetTarget(configuration);
-        }
-        super.removeAllAdapters();
+    protected boolean canEdit(Object element) {
+      return true;
+    }
+
+    /**
+     * @see EditingSupport#getCellEditor(Object)
+     */
+    @Override
+    protected CellEditor getCellEditor(Object element) {
+      return cellEditor;
+    }
+  }
+
+  /**
+   * Editing support for the column "key".
+   */
+  private class EditingSupportColKey extends CellEditingSupport {
+    public EditingSupportColKey(TreeViewer viewer) {
+      super(viewer);
     }
 
     @Override
-    protected void basicSetInput(EObject newInput)
-    {
-        super.basicSetInput(newInput == null ? null : ((InvokePipelet) newInput).getPipeletConfiguration());
+    protected Object getValue(Object element) {
+      if (element instanceof RecordAny) {
+        Object o = ((RecordAny) element).getKey();
+        return o != null ? o : "";
+      } else {
+        return null;
+      }
+    }
 
-        if (getInput() != null)
-        {
-            propertiesViewer.setInput(getInput());
-        }
+    /**
+     * @see PipeletConfigurationSection.CellEditingSupport#canEdit(java.lang.Object)
+     */
+    @Override
+    protected boolean canEdit(Object element) {
+      return element instanceof RecordAny && ((RecordAny) element).getContainer() instanceof RecordMap;
     }
 
     @Override
-    protected void createClient(Composite parent)
-    {
-        parent.setLayout(new FillLayout());
+    protected void setValue(Object element, Object value) {
+      getCommandFramework().execute(
+        wrapInShowContextCommand(new SetCommand((RecordAny) element, value, RecordPackage.eINSTANCE
+          .getRecordAny_Key())));
+    }
+  }
 
-        // create table
-        propertiesTable = fWidgetFactory.createTable(parent, SWT.FULL_SELECTION | SWT.V_SCROLL);
-
-        propertiesTable.setLinesVisible(true);
-        propertiesTable.setHeaderVisible(true);
-
-        tableProvider = new ColumnTableProvider();
-        tableProvider.add(new NameColumn());
-        tableProvider.add(new ValueColumn());
-
-        propertiesViewer = new TableViewer(propertiesTable);
-        tableProvider.createTableLayout(propertiesTable);
-        propertiesViewer.setLabelProvider(tableProvider);
-        propertiesViewer.setCellModifier(tableProvider);
-        propertiesViewer.setContentProvider(new PipeletConfigurationProvider());
-        propertiesViewer.setColumnProperties(tableProvider.getColumnProperties());
-        propertiesViewer.setCellEditors(tableProvider.createCellEditors(propertiesTable));
-
-        // Create menu
-        Menu tableMenu = new Menu(parent);
-
-        MenuItem addPropertyMenuItem = new MenuItem(tableMenu, SWT.PUSH);
-        addPropertyMenuItem.setText("Add property");
-        addPropertyMenuItem.addSelectionListener(new SelectionListener()
-        {
-            @Override
-            public void widgetSelected(SelectionEvent e)
-            {
-                addProperty("New property");
-            }
-
-            @Override
-            public void widgetDefaultSelected(SelectionEvent e)
-            {
-                // Nothing to do
-            }
-        });
-
-        new MenuItem(tableMenu, SWT.SEPARATOR);
-
-        final MenuItem removePropertyMenuItem = new MenuItem(tableMenu, SWT.PUSH);
-        removePropertyMenuItem.setText("Remove property");
-        removePropertyMenuItem.addSelectionListener(new SelectionListener()
-        {
-            @Override
-            public void widgetSelected(SelectionEvent e)
-            {
-                // Remove property
-                TableItem[] items = propertiesTable.getSelection();
-                if (items.length > 0)
-                {
-                    getCommandFramework().execute(
-                            wrapInShowContextCommand(new RemoveFromListCommand(getInput(), items[0].getData(),
-                                    "Remove property")
-                            {
-                                @Override
-                                protected List<?> getList()
-                                {
-                                    return ((PipeletConfiguration) target).getProperties();
-                                }
-                            }));
-                }
-            }
-
-            @Override
-            public void widgetDefaultSelected(SelectionEvent e)
-            {
-                // Nothing to do
-            }
-        });
-
-        propertiesTable.setMenu(tableMenu);
-        propertiesTable.addMenuDetectListener(new MenuDetectListener()
-        {
-            @Override
-            public void menuDetected(MenuDetectEvent e)
-            {
-                int index = propertiesTable.getSelectionIndex();
-                removePropertyMenuItem.setEnabled(index >= 0 && index < propertiesTable.getItemCount() - 1);
-            }
-        });
-
-        // TODO Add help reference
-        // PlatformUI.getWorkbench().getHelpSystem().setHelp(parentComposite, IHelpContextIds.PROPERTY_PAGE_BPEL_NAMESPACE_PREFIXES);
+  /**
+   * Editing support for the column "value".
+   */
+  private class EditingSupportColValue extends CellEditingSupport {
+    public EditingSupportColValue(TreeViewer viewer) {
+      super(viewer);
     }
 
     @Override
-    public Object getUserContext()
-    {
-        return ((StructuredSelection) propertiesViewer.getSelection()).getFirstElement();
+    protected boolean canEdit(Object element) {
+      return element instanceof RecordVal;
     }
 
     @Override
-    public void restoreUserContext(Object userContext)
-    {
-        propertiesTable.setFocus();
-        if (userContext != null)
-        {
-            propertiesViewer.setSelection(new StructuredSelection(userContext));
-        }
+    protected Object getValue(Object element) {
+      return ((RecordVal) element).getValue() != null ? ((RecordVal) element).getType().format(
+        ((RecordVal) element).getValue()) : "";
     }
 
-    private void addProperty(String name)
-    {
-        Property newProperty = ProcessorFactory.eINSTANCE.createProperty();
-        newProperty.setName(name);
-        newProperty.setValue("");
-        getCommandFramework().execute(wrapInShowContextCommand(new AddToListCommand(getInput(), newProperty, "Add property")
-        {
-            @Override
-            protected List<?> getList()
-            {
-                return ((PipeletConfiguration) target).getProperties();
-            }
-        }));
-    }
-
-    private final class NameColumn extends ColumnTableProvider.Column implements ILabelProvider, ICellModifier
-    {
-
-        @Override
-        public String getHeaderText()
-        {
-            return "Name";
-        }
-
-        @Override
-        public String getProperty()
-        {
-            return "Name";
-        }
-
-        @Override
-        public int getInitialWeight()
-        {
-            return 10;
-        }
-
-        @Override
-        public String getText(Object element)
-        {
-            return element instanceof Property ? ((Property) element).getName() : "";
-        }
-
-        /**
-         * @see ICellModifier#canModify(Object, String)
-         */
-        @Override
-        public boolean canModify(Object element, String property)
-        {
-            return true;
-        }
-
-        /**
-         * @see ICellModifier#getValue(Object, String)
-         */
-        @Override
-        public Object getValue(Object element, String property)
-        {
-            return getText(element);
-        }
-
-        /**
-         * @see ICellModifier#modify(Object, String, Object)
-         */
-        @Override
-        public void modify(Object element, String property, Object value)
-        {
-            String name = value == null ? "" : value.toString().trim();
-            if (element instanceof Property)
-            {
-                if (name.length() == 0)
-                {
-                    // Remove property
-                    getCommandFramework().execute(
-                            wrapInShowContextCommand(new RemoveFromListCommand(getInput(), element, "Remove property")
-                            {
-                                @Override
-                                protected List<?> getList()
-                                {
-                                    return ((PipeletConfiguration) target).getProperties();
-                                }
-                            }));
-                }
-                else
-                {
-                    // Modify property
-                    getCommandFramework().execute(
-                            wrapInShowContextCommand(new SetCommand((Property) element, value, ProcessorPackage.eINSTANCE
-                                    .getProperty_Name())));
-                }
-            }
-            else if (name.length() > 0)
-            {
-                // Create new property
-                addProperty(name);
-            }
-        }
-
-        /**
-         * @see org.eclipse.bpel.ui.details.providers.ColumnTableProvider.Column#createCellEditor(Composite)
-         */
-        @Override
-        public CellEditor createCellEditor(Composite parent)
-        {
-            return new TextCellEditor(parent);
-        }
+    @Override
+    protected void setValue(Object element, Object value) {
+      RecordVal recordVal = (RecordVal) element;
+      RecordVal.Type type = recordVal.getType() != null ? recordVal.getType() : RecordVal.Type.STRING;
+      try {
+        value = type.parse(value.toString());
+        getCommandFramework().execute(
+          wrapInShowContextCommand(new SetCommand(recordVal, value, RecordPackage.eINSTANCE.getRecordVal_Value())));
+      } catch (ParseException pe) {
+        MessageDialog.openError(compositeTree.getShell(), "Parse Error",
+          MessageFormat.format("Error parsing ''{0}'' as ''{1}''!", value.toString(), type));
+      }
 
     }
 
-    private final class ValueColumn extends ColumnTableProvider.Column implements ILabelProvider, ICellModifier
-    {
+    /**
+     * @see EditingSupport#getCellEditor(Object)
+     */
+    @Override
+    protected CellEditor getCellEditor(Object element) {
+      return super.cellEditor;
+    }
+  }
+
+  /**
+   * Editing support for the column "type".
+   */
+  private class EditingSupportColType extends CellEditingSupport {
+    private final ComboBoxCellEditor comboBoxCellEditor;
+
+    /**
+     * Creates a new instance of EditingSupportColType.
+     * 
+     * @param viewer
+     *          The viewer for which columns the EditorSupport should be enabled
+     */
+    public EditingSupportColType(TreeViewer viewer) {
+      super(viewer);
+      List<String> items = new ArrayList<String>();
+      for (RecordVal.Type type : RecordVal.Type.values()) {
+        items.add(type.name());
+      }
+      this.comboBoxCellEditor = new ComboBoxCellEditor(viewer.getTree(), items.toArray(new String[] {}));
+      ((CCombo) this.comboBoxCellEditor.getControl()).addSelectionListener(new SelectionListener() {
         @Override
-        public String getHeaderText()
-        {
-            return "Value";
+        public void widgetSelected(SelectionEvent e) {
+          comboBoxCellEditor.deactivate();
         }
 
         @Override
-        public String getProperty()
-        {
-            return "Value";
+        public void widgetDefaultSelected(SelectionEvent e) {
+          // Nothing to do
         }
+      });
+    }
 
-        @Override
-        public int getInitialWeight()
-        {
-            return 30;
+    /**
+     * @see EditingSupport#canEdit(Object)
+     */
+    @Override
+    protected boolean canEdit(Object element) {
+      return element instanceof RecordVal;
+    }
+
+    /**
+     * @see EditingSupport#getCellEditor(Object)
+     */
+    @Override
+    protected CellEditor getCellEditor(Object element) {
+      return comboBoxCellEditor;
+    }
+
+    /**
+     * @see EditingSupport#getValue(Object)
+     */
+    @Override
+    protected Object getValue(Object element) {
+      if (element != null && ((RecordAny) element).isVal()) {
+        RecordVal recordVal = (RecordVal) element;
+        if (recordVal.getType() != null) {
+          return recordVal.getType().ordinal();
+        } else {
+          return RecordVal.Type.STRING.ordinal();
         }
+      }
+      return null;
+    }
 
-        @Override
-        public String getText(Object element)
-        {
-            return element instanceof Property ? ((Property) element).getValue() : "";
-        }
-
-        /**
-         * @see ICellModifier#canModify(Object, String)
-         */
-        @Override
-        public boolean canModify(Object element, String property)
-        {
-            return element instanceof Property;
-        }
-
-        /**
-         * @see ICellModifier#getValue(Object, String)
-         */
-        @Override
-        public Object getValue(Object element, String property)
-        {
-            return getText(element);
-        }
-
-        /**
-         * @see ICellModifier#modify(Object, String, Object)
-         */
-        @Override
-        public void modify(Object element, String property, Object value)
-        {
-            if (element instanceof Property)
-            {
-                getCommandFramework().execute(
-                        wrapInShowContextCommand(new SetCommand((Property) element, value, ProcessorPackage.eINSTANCE
-                                .getProperty_Value())));
+    /**
+     * @see EditingSupport#setValue(Object, Object)
+     */
+    @Override
+    protected void setValue(Object element, Object value) {
+      RecordVal recordVal = (RecordVal) element;
+      RecordVal.Type newType = RecordVal.Type.values()[((Integer) value)];
+      try {
+        Object newValue;
+        if (recordVal.getValue() == null || "".equals(recordVal.getValue())) {
+          switch (newType) {
+            case BOOLEAN: {
+              newValue = new Boolean(false);
+              break;
             }
+            case DATE: {
+              newValue = new java.sql.Date(System.currentTimeMillis());
+              break;
+            }
+            case DATETIME: {
+              newValue = new java.sql.Timestamp(System.currentTimeMillis());
+              break;
+            }
+            case DOUBLE: {
+              newValue = new Double(0);
+              break;
+            }
+            case LONG: {
+              newValue = new Long(0);
+              break;
+            }
+            default:
+            case STRING: {
+              newValue = "";
+            }
+          }
+        } else {
+          newValue = newType.parse(recordVal.getValue().toString());
         }
-
-        /**
-         * @see org.eclipse.bpel.ui.details.providers.ColumnTableProvider.Column#createCellEditor(Composite)
-         */
-        @Override
-        public CellEditor createCellEditor(Composite parent)
-        {
-            return new TextCellEditor(parent);
-        }
+        getCommandFramework()
+          .execute(
+            wrapInShowContextCommand(new SetCommand(recordVal, newValue, RecordPackage.eINSTANCE
+              .getRecordVal_Value())));
+      } catch (ParseException pe) {
+        MessageDialog.openError(compositeTree.getShell(), "Parse Error", MessageFormat.format(
+          "Error parsing ''{0}'' as ''{1}''!", recordVal.getValue().toString(), newType.name()));
+      }
 
     }
+  }
+
+  /**
+   * ColumnViewerEditorActivationStrategy for the treeViewer. Defines that the columns will be editable after a
+   * doubleclick on them.
+   */
+  private class TreeViewerColumnViewerEditorActivationStrategy extends ColumnViewerEditorActivationStrategy {
+    /**
+     * Creates a new instance of {@link TreeViewerColumnViewerEditorActivationStrategy}.
+     * 
+     * @param viewer
+     *          The viewer on which this strategy should be used.
+     */
+    public TreeViewerColumnViewerEditorActivationStrategy(ColumnViewer viewer) {
+      super(viewer);
+    }
+
+    /**
+     * @see ColumnViewerEditorActivationStrategy#isEditorActivationEvent(ColumnViewerEditorActivationEvent)
+     */
+    @Override
+    protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
+      MouseEvent mouseEvent = (MouseEvent) event.sourceEvent;
+      boolean singleSelect = ((IStructuredSelection) treeViewer.getSelection()).size() == 1;
+      boolean isLeftMouseDoubleSelect =
+        event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION && mouseEvent.button == 1;
+      return singleSelect
+        && (isLeftMouseDoubleSelect || event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC
+          || event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL || (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR));
+    }
+  }
+
+  /**
+   * Creates a new value and adds it to the current selected map or list.
+   */
+  private final class CreateValueMenuAction extends SelectionAdapter {
+    private final EClass valueClass;
+
+    /**
+     * Creates a new instance of AddMenuAction.
+     * 
+     * @param valueClass
+     */
+    public CreateValueMenuAction(EClass valueClass) {
+      this.valueClass = valueClass;
+    }
+
+    @Override
+    public void widgetSelected(SelectionEvent e) {
+      TreeItem treeItem =
+        treeViewer.getTree().getSelectionCount() > 0 ? treeViewer.getTree().getSelection()[0] : null;
+
+      RecordValues parent;
+      if (treeItem == null) {
+        parent = getConfiguration();
+      } else {
+        RecordAny value = (RecordAny) treeItem.getData();
+        if (value.isVal()) {
+          parent = (RecordValues) value.getContainer();
+        } else {
+          parent = (RecordValues) value;
+        }
+      }
+
+      RecordAny newValue = (RecordAny) RecordFactory.eINSTANCE.create(valueClass);
+      if (parent.isMap()) {
+        newValue.setKey("KEY");
+      }
+
+      getCommandFramework().execute(
+        wrapInShowContextCommand(new AddToListFeatureCommand(parent, newValue, RecordPackage.eINSTANCE
+          .getRecordValues_Values())));
+    }
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletTypeSection.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletTypeSection.java
index eccd88b..954ba53 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletTypeSection.java
+++ b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/PipeletTypeSection.java
@@ -1,8 +1,7 @@
 /***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
+ * Copyright (c) 2010 Attensity Europe GmbH. 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
  **********************************************************************************************************************/
 package org.eclipse.smila.processing.designer.ui.properties;
 
@@ -26,175 +25,158 @@
 
 /**
  * The type section for the InvokePipelet activity.
- *
+ * 
  * Copyright (c) 2010 Attensity Europe GmbH
- *
+ * 
  * @author Tobias Liefke
  */
-public class PipeletTypeSection extends BPELPropertySection
-{
-    private CCombo typeField;
-    private EditController typeEditController;
-    private InvokePipeletAdapter pipeletAdapter;
+public class PipeletTypeSection extends BPELPropertySection {
+  private CCombo typeField;
 
-    /**
-     * Changes the content of the text field.
-     * 
-     * @see BPELPropertySection#basicSetInput(EObject)
-     */
-    @Override
-    protected void basicSetInput(EObject input)
-    {
-        super.basicSetInput(input);
+  private EditController typeEditController;
 
-        pipeletAdapter = BPELUtil.adapt(input, InvokePipeletAdapter.class);
-        typeEditController.setInput(input);
-    }
+  private InvokePipeletAdapter pipeletAdapter;
 
-    /**
-     * Create the components and event handlers.
-     * 
-     * @see BPELPropertySection#createClient(Composite)
-     */
-    @Override
-    protected void createClient(Composite parent)
-    {
-        createComponents(parent);
-        createChangeTrackers();
-    }
+  /**
+   * Changes the content of the text field.
+   * 
+   * @see BPELPropertySection#basicSetInput(EObject)
+   */
+  @Override
+  protected void basicSetInput(EObject input) {
+    super.basicSetInput(input);
 
-    /**
-     * Create the components.
-     *
-     * @param composite the parent
-     */
-    private void createComponents(Composite parent)
-    {
-        Composite composite = createFlatFormComposite(parent);
+    pipeletAdapter = BPELUtil.adapt(input, InvokePipeletAdapter.class);
+    typeEditController.setInput(input);
+  }
 
-        DecoratedLabel typeLabel = new DecoratedLabel(composite, SWT.LEFT);
-        fWidgetFactory.adapt(typeLabel);
-        typeLabel.setText("Type:");
+  /**
+   * Create the components and event handlers.
+   * 
+   * @see BPELPropertySection#createClient(Composite)
+   */
+  @Override
+  protected void createClient(Composite parent) {
+    createComponents(parent);
+    createChangeTrackers();
+  }
 
-        typeField = fWidgetFactory.createCCombo(composite, SWT.FLAT);
-        FlatFormData data = new FlatFormData();
-        data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(typeLabel, STANDARD_LABEL_WIDTH_AVG));
-        data.right = new FlatFormAttachment(100, (-2) * IDetailsAreaConstants.HSPACE);
-        data.top = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE);
-        typeField.setLayoutData(data);
-        typeField.add("org.eclipse.smila.ontology.pipelets.CreateFileUriPipelet");
-        typeField.add("org.eclipse.smila.ontology.pipelets.CreateRelationPipelet");
-        typeField.add("org.eclipse.smila.ontology.pipelets.CreateResourcePipelet");
-        typeField.add("org.eclipse.smila.ontology.pipelets.SesameRecordReaderPipelet");
-        typeField.add("org.eclipse.smila.ontology.pipelets.SesameRecordWriterPipelet");
-        typeField.add("org.eclipse.smila.processing.bpel.pipelet.AddLiteralPipelet");
-        typeField.add("org.eclipse.smila.processing.bpel.pipelet.ErrorPipelet");
-        typeField.add("org.eclipse.smila.processing.bpel.pipelet.SearchTestPipelet");
-        typeField.add("org.eclipse.smila.processing.bpel.pipelet.SimpleTestPipelet");
-        typeField.add("org.eclipse.smila.processing.bpel.pipelet.SplitterPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.AddLiteralsPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.CommitRecordsPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.CopyPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.HtmlToTextPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.SetAnnotationPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.SubAttributeExtractorPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.RemoveElementFromXMLPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.TidyPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XPathExtractorPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XPathFilterPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XslTransformationPipelet");
-        typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XmlSplitterPipelet");
+  /**
+   * Create the components.
+   * 
+   * @param composite
+   *          the parent
+   */
+  private void createComponents(Composite parent) {
+    Composite composite = createFlatFormComposite(parent);
 
-        data = new FlatFormData();
-        data.left = new FlatFormAttachment(0, 0);
-        data.right = new FlatFormAttachment(typeField, -IDetailsAreaConstants.HSPACE);
-        data.top = new FlatFormAttachment(typeField, 0, SWT.CENTER);
-        typeLabel.setLayoutData(data);
+    DecoratedLabel typeLabel = new DecoratedLabel(composite, SWT.LEFT);
+    fWidgetFactory.adapt(typeLabel);
+    typeLabel.setText("Type:");
 
-        // TODO Add help reference
-        // PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IHelpContextIds.PROPERTY_PAGE_NAME);
-    }
+    typeField = fWidgetFactory.createCCombo(composite, SWT.FLAT);
+    FlatFormData data = new FlatFormData();
+    data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(typeLabel, STANDARD_LABEL_WIDTH_AVG));
+    data.right = new FlatFormAttachment(100, (-2) * IDetailsAreaConstants.HSPACE);
+    data.top = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE);
+    typeField.setLayoutData(data);
+    typeField.add("org.eclipse.smila.ontology.pipelets.CreateFileUriPipelet");
+    typeField.add("org.eclipse.smila.ontology.pipelets.CreateRelationPipelet");
+    typeField.add("org.eclipse.smila.ontology.pipelets.CreateResourcePipelet");
+    typeField.add("org.eclipse.smila.ontology.pipelets.SesameRecordReaderPipelet");
+    typeField.add("org.eclipse.smila.ontology.pipelets.SesameRecordWriterPipelet");
+    typeField.add("org.eclipse.smila.processing.bpel.pipelet.AddLiteralPipelet");
+    typeField.add("org.eclipse.smila.processing.bpel.pipelet.ErrorPipelet");
+    typeField.add("org.eclipse.smila.processing.bpel.pipelet.SearchTestPipelet");
+    typeField.add("org.eclipse.smila.processing.bpel.pipelet.SimpleTestPipelet");
+    typeField.add("org.eclipse.smila.processing.bpel.pipelet.SplitterPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.AddLiteralsPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.CommitRecordsPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.CopyPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.HtmlToTextPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.SetAnnotationPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.SubAttributeExtractorPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.RemoveElementFromXMLPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.TidyPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XPathExtractorPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XPathFilterPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XslTransformationPipelet");
+    typeField.add("org.eclipse.smila.processing.pipelets.xmlprocessing.XmlSplitterPipelet");
 
-    /**
-     * Create the event listeners.
-     */
-    private void createChangeTrackers()
-    {
-        typeEditController = new EditController(getCommandFramework())
-        {
-            @Override
-            public boolean checkNotification(Notification notification)
-            {
-                return notification.getFeatureID(Pipelet.class) == ProcessorPackage.PIPELET__CLASS;
-            }
+    data = new FlatFormData();
+    data.left = new FlatFormAttachment(0, 0);
+    data.right = new FlatFormAttachment(typeField, -IDetailsAreaConstants.HSPACE);
+    data.top = new FlatFormAttachment(typeField, 0, SWT.CENTER);
+    typeLabel.setLayoutData(data);
 
-            @Override
-            public Command createApplyCommand()
-            {
-                return wrapInShowContextCommand(super.createApplyCommand());
-            }
+    // TODO Add help reference
+    // PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IHelpContextIds.PROPERTY_PAGE_NAME);
+  }
 
-        };
-        typeEditController.setLabel(ProcessorPackage.eINSTANCE.getPipelet_Class().getName());
+  /**
+   * Create the event listeners.
+   */
+  private void createChangeTrackers() {
+    typeEditController = new EditController(getCommandFramework()) {
+      @Override
+      public boolean checkNotification(Notification notification) {
+        return notification.getFeatureID(Pipelet.class) == ProcessorPackage.PIPELET__CLASS;
+      }
 
-        typeEditController.setViewIValue(new IValue()
-        {
-            @Override
-            public Object get()
-            {
-                return typeField.getText();
-            }
+      @Override
+      public Command createApplyCommand() {
+        return wrapInShowContextCommand(super.createApplyCommand());
+      }
 
-            @Override
-            public void set(Object text)
-            {
-                if (text == null)
-                {
-                    typeField.setText("");
-                }
-                else
-                {
-                    typeField.setText(text.toString());
-                }
-            }
-        });
-        typeEditController.setModeIValue(new IValue()
-        {
-            @Override
-            public Object get()
-            {
-                return pipeletAdapter != null ? pipeletAdapter.getClassName(typeEditController.getInput()) : null;
-            }
+    };
+    typeEditController.setLabel(ProcessorPackage.eINSTANCE.getPipelet_Class().getName());
 
-            @Override
-            public void set(Object object)
-            {
-                if (pipeletAdapter != null)
-                {
-                    pipeletAdapter.setClassName(typeEditController.getInput(), object.toString());
-                }
-            }
-        });
+    typeEditController.setViewIValue(new IValue() {
+      @Override
+      public Object get() {
+        return typeField.getText();
+      }
 
-        typeEditController.startListeningTo(typeField);
-    }
+      @Override
+      public void set(Object text) {
+        if (text == null) {
+          typeField.setText("");
+        } else {
+          typeField.setText(text.toString());
+        }
+      }
+    });
+    typeEditController.setModeIValue(new IValue() {
+      @Override
+      public Object get() {
+        return pipeletAdapter != null ? pipeletAdapter.getClassName(typeEditController.getInput()) : null;
+      }
 
-    /**
-     * @see org.eclipse.bpel.ui.properties.BPELPropertySection#getUserContext()
-     */
-    @Override
-    public Object getUserContext()
-    {
-        return null;
-    }
+      @Override
+      public void set(Object object) {
+        if (pipeletAdapter != null) {
+          pipeletAdapter.setClassName(typeEditController.getInput(), object.toString());
+        }
+      }
+    });
 
-    /**
-     * @see BPELPropertySection#restoreUserContext(Object)
-     */
-    @Override
-    public void restoreUserContext(Object userContext)
-    {
-        typeField.setFocus();
-    }
+    typeEditController.startListeningTo(typeField);
+  }
+
+  /**
+   * @see org.eclipse.bpel.ui.properties.BPELPropertySection#getUserContext()
+   */
+  @Override
+  public Object getUserContext() {
+    return null;
+  }
+
+  /**
+   * @see BPELPropertySection#restoreUserContext(Object)
+   */
+  @Override
+  public void restoreUserContext(Object userContext) {
+    typeField.setFocus();
+  }
 
 }
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/ServiceTypeSection.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/ServiceTypeSection.java
deleted file mode 100644
index 068b816..0000000
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/ServiceTypeSection.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.ui.properties;
-
-import org.eclipse.bpel.common.ui.details.*;
-import org.eclipse.bpel.common.ui.details.widgets.DecoratedLabel;
-import org.eclipse.bpel.common.ui.flatui.FlatFormAttachment;
-import org.eclipse.bpel.common.ui.flatui.FlatFormData;
-import org.eclipse.bpel.ui.properties.BPELPropertySection;
-import org.eclipse.bpel.ui.properties.EditController;
-import org.eclipse.bpel.ui.util.BPELUtil;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.gef.commands.Command;
-import org.eclipse.smila.processing.designer.model.processor.*;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.widgets.Composite;
-import org.eclipse.swt.widgets.Text;
-
-/**
- * The type section for the InvokeServlet activity.
- *
- * Copyright (c) 2010 Attensity Europe GmbH
- *
- * @author Tobias Liefke
- */
-public class ServiceTypeSection extends BPELPropertySection
-{
-    private Text typeTextField;
-    private EditController typeEditController;
-
-    /**
-     * Changes the content of the text field.
-     * 
-     * @see BPELPropertySection#basicSetInput(EObject)
-     */
-    @Override
-    protected void basicSetInput(EObject input)
-    {
-        super.basicSetInput(input);
-
-        typeEditController.setInput(input);
-    }
-
-    /**
-     * Create the components and event handlers.
-     * 
-     * @see BPELPropertySection#createClient(Composite)
-     */
-    @Override
-    protected void createClient(Composite parent)
-    {
-        createComponents(parent);
-        createChangeTrackers();
-    }
-
-    /**
-     * Create the components.
-     *
-     * @param composite the parent
-     */
-    private void createComponents(Composite parent)
-    {
-        Composite composite = createFlatFormComposite(parent);
-
-        DecoratedLabel typeLabel = new DecoratedLabel(composite, SWT.LEFT);
-        fWidgetFactory.adapt(typeLabel);
-        typeLabel.setText("Servicename:");
-
-        typeTextField = fWidgetFactory.createText(composite, EMPTY_STRING);
-        FlatFormData data = new FlatFormData();
-        data.left = new FlatFormAttachment(0, BPELUtil.calculateLabelWidth(typeLabel, STANDARD_LABEL_WIDTH_AVG));
-        data.right = new FlatFormAttachment(100, (-2) * IDetailsAreaConstants.HSPACE);
-        data.top = new FlatFormAttachment(0, IDetailsAreaConstants.VSPACE);
-        typeTextField.setLayoutData(data);
-
-        data = new FlatFormData();
-        data.left = new FlatFormAttachment(0, 0);
-        data.right = new FlatFormAttachment(typeTextField, -IDetailsAreaConstants.HSPACE);
-        data.top = new FlatFormAttachment(typeTextField, 0, SWT.CENTER);
-        typeLabel.setLayoutData(data);
-
-        // TODO Add help reference
-        // PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, IHelpContextIds.PROPERTY_PAGE_NAME);
-    }
-
-    /**
-     * Create the event listeners.
-     */
-    private void createChangeTrackers()
-    {
-        typeEditController = new EditController(getCommandFramework())
-        {
-            @Override
-            public boolean checkNotification(Notification notification)
-            {
-                return notification.getFeatureID(Service.class) == ProcessorPackage.SERVICE__NAME;
-            }
-
-            @Override
-            public Command createApplyCommand()
-            {
-                return wrapInShowContextCommand(super.createApplyCommand());
-            }
-
-        };
-        typeEditController.setLabel(ProcessorPackage.eINSTANCE.getPipelet_Class().getName());
-
-        typeEditController.setViewIValue(new TextIValue(typeTextField));
-        typeEditController.setModeIValue(new IValue()
-        {
-            @Override
-            public Object get()
-            {
-                InvokeService invokeService = (InvokeService) typeEditController.getInput();
-                return invokeService == null || invokeService.getService() == null ? "" : invokeService.getService().getName();
-            }
-
-            @Override
-            public void set(Object object)
-            {
-                InvokeService invokeService = (InvokeService) typeEditController.getInput();
-                if (invokeService != null)
-                {
-                    invokeService.getService().setName(object.toString());
-                }
-            }
-        });
-
-        typeEditController.startListeningTo(typeTextField);
-    }
-
-    /**
-     * @see org.eclipse.bpel.ui.properties.BPELPropertySection#getUserContext()
-     */
-    @Override
-    public Object getUserContext()
-    {
-        return null;
-    }
-
-    /**
-     * @see BPELPropertySection#restoreUserContext(Object)
-     */
-    @Override
-    public void restoreUserContext(Object userContext)
-    {
-        typeTextField.setFocus();
-    }
-
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/SetAnnotationsSection.java b/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/SetAnnotationsSection.java
deleted file mode 100644
index 2b5ddd8..0000000
--- a/tooling/org.eclipse.smila.processing.designer.ui/code/src/org/eclipse/smila/processing/designer/ui/properties/SetAnnotationsSection.java
+++ /dev/null
@@ -1,598 +0,0 @@
-/***********************************************************************************************************************
- * Copyright (c) 2010 Attensity Europe GmbH. 
- * 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
- **********************************************************************************************************************/
-package org.eclipse.smila.processing.designer.ui.properties;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.bpel.ui.properties.BPELPropertySection;
-import org.eclipse.bpel.ui.util.MultiObjectAdapter;
-import org.eclipse.emf.common.notify.Notification;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.jface.viewers.*;
-import org.eclipse.smila.processing.designer.model.processor.InvokeService;
-import org.eclipse.smila.processing.designer.model.processor.SetAnnotations;
-import org.eclipse.smila.processing.designer.model.record.*;
-import org.eclipse.smila.processing.designer.ui.Activator;
-import org.eclipse.smila.processing.designer.ui.SMILADesignerUIConstants;
-import org.eclipse.swt.SWT;
-import org.eclipse.swt.events.*;
-import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.graphics.Point;
-import org.eclipse.swt.layout.GridData;
-import org.eclipse.swt.layout.GridLayout;
-import org.eclipse.swt.widgets.*;
-
-/**
- * Show the SetAnnotations options of a service.
- * 
- * Copyright (c) 2011 Attensity Europe GmbH
- * 
- * @author Lars Kunze
- * 
- */
-public class SetAnnotationsSection extends BPELPropertySection
-{
-    private static final String LABEL_COLUMN_NAME = "Name";
-    private static final String LABEL_COLUMN_VALUE = "Value";
-    private static final String LABLE_MENU_ITEM_ADD_ANNOTATION = "Add annotation";
-    private static final String LABLE_MENU_ITEM_ADD_ANNOTATION_VALUE = "Add annotation value";
-    private static final String LABLE_MENU_ITEM_REMOVE = "Remove";
-
-    private static enum menuActions
-    {
-        ADD_ANNOTATION(0), ADD_ANNOTATION_VALUE(1), DELETE_ITEM(2);
-
-        private int index;
-
-        private menuActions(int index)
-        {
-            this.index = index;
-        }
-    }
-
-    private Composite compositeTree;
-    private TreeViewer treeViewer;
-
-    // ### Override/implement methods ###
-
-    /**
-     * @see BPELPropertySection#shouldUseExtraSpace()
-     */
-    @Override
-    public boolean shouldUseExtraSpace()
-    {
-        return true;
-    }
-
-    /**
-     * @see BPELPropertySection#createAdapters()
-     */
-    @Override
-    protected MultiObjectAdapter[] createAdapters()
-    {
-        return new MultiObjectAdapter[] {new MultiObjectAdapter()
-        {
-            @Override
-            public void notify(Notification n)
-            {
-                treeViewer.setInput(getInput());
-            }
-        }};
-    }
-
-    /**
-     * @see BPELPropertySection#basicSetInput(EObject)
-     */
-    @Override
-    protected void basicSetInput(EObject newInput)
-    {
-        super.basicSetInput(newInput == null ? null : ((InvokeService) newInput).getSetAnnotations());
-
-        if (getInput() != null)
-        {
-            treeViewer.setInput(getInput());
-        }
-    }
-
-    /**
-     * @see BPELPropertySection#createClient()
-     */
-    @Override
-    protected void createClient(Composite parent)
-    {
-        createComponents(parent);
-    }
-
-    // ### Utility methods ###
-
-    /**
-     * Creates the components of this section.
-     * 
-     * @param parent
-     */
-    private void createComponents(Composite parent)
-    {
-        parent.setLayout(new GridLayout(1, false));
-
-        // (1) Tree
-        compositeTree = new Composite(parent, SWT.NONE);
-        compositeTree.setLayout(new GridLayout(1, false));
-        compositeTree.setLayoutData(new GridData(GridData.FILL_BOTH));
-
-        treeViewer = new TreeViewer(compositeTree, SWT.FULL_SELECTION);
-        treeViewer.setContentProvider(new TreeViewerContentProvider());
-        treeViewer.getTree().addMouseListener(new TreeViewerMouseListener());
-        treeViewer.getTree().setHeaderVisible(true);
-        treeViewer.getTree().setLinesVisible(true);
-        treeViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
-        treeViewer.setAutoExpandLevel(3);
-
-        // (2) TreeColumns
-        TreeViewerColumn treeViewerColumnName = new TreeViewerColumn(treeViewer, SWT.NONE);
-        treeViewerColumnName.getColumn().setText(LABEL_COLUMN_NAME);
-        treeViewerColumnName.getColumn().setWidth(200);
-        treeViewerColumnName.setLabelProvider(new TreeViewerLabelProviderName());
-        treeViewerColumnName.setEditingSupport(new TreeViewerEditingSupport(treeViewer, 0));
-
-        TreeViewerColumn treeViewerColumnValue = new TreeViewerColumn(treeViewer, SWT.NONE);
-        treeViewerColumnValue.getColumn().setText(LABEL_COLUMN_VALUE);
-        treeViewerColumnValue.getColumn().setWidth(200);
-        treeViewerColumnValue.setLabelProvider(new TreeViewerLabelProviderValue());
-        treeViewerColumnValue.setEditingSupport(new TreeViewerEditingSupport(treeViewer, 1));
-
-        // (3) ColumnViewerEditor
-        TreeViewerEditor.create(treeViewer, new TreeViewerColumnViewerEditorActivationStrategy(treeViewer),
-                ColumnViewerEditor.KEYBOARD_ACTIVATION);
-
-        // (4) TreeMenu
-        Menu menuTree = new Menu(parent);
-        MenuItem menuItemAddAnnotation = new MenuItem(menuTree, SWT.PUSH);
-        menuItemAddAnnotation.setText(LABLE_MENU_ITEM_ADD_ANNOTATION);
-        menuItemAddAnnotation.setData(menuActions.ADD_ANNOTATION);
-        menuItemAddAnnotation.setImage(Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.ANNOTATION_ICON_16)
-                .createImage());
-        menuItemAddAnnotation.addSelectionListener(new MenuItemSelectionListener());
-        MenuItem menuItemAddAnnotationValue = new MenuItem(menuTree, SWT.PUSH);
-        menuItemAddAnnotationValue.setText(LABLE_MENU_ITEM_ADD_ANNOTATION_VALUE);
-        menuItemAddAnnotationValue.setData(menuActions.ADD_ANNOTATION_VALUE);
-        menuItemAddAnnotationValue.setImage(Activator.getDefault()
-                .getImageDescriptor(SMILADesignerUIConstants.ANNOTATION_VALUE_ICON_16).createImage());
-        menuItemAddAnnotationValue.addSelectionListener(new MenuItemSelectionListener());
-        MenuItem menuItemRemove = new MenuItem(menuTree, SWT.PUSH);
-        menuItemRemove.setText(LABLE_MENU_ITEM_REMOVE);
-        menuItemRemove.setData(menuActions.DELETE_ITEM);
-        menuItemRemove.addSelectionListener(new MenuItemSelectionListener());
-
-        treeViewer.getTree().setMenu(menuTree);
-    }
-
-    // ### Inner classes ###
-
-    /**
-     * Implementation of the ITreeContentProvider interface for the treeViewer.
-     */
-    class TreeViewerContentProvider implements ITreeContentProvider
-    {
-        /**
-        * @see ITreeContentProvider#dispose()
-        */
-        @Override
-        public void dispose()
-        {
-            // Nothing todo
-        }
-
-        /**
-         * @see ITreeContentProvider#inputChanged(Viewer, Object, Object)
-         */
-        @Override
-        public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
-        {
-            // Nothing todo
-        }
-
-        /**
-         * @see ITreeContentProvider#getElements(Object)
-         */
-        @Override
-        public Object[] getElements(Object inputElement)
-        {
-            return getChildren(inputElement);
-        }
-
-        /**
-         * @see ITreeContentProvider#getChildren(Object)
-         */
-        @Override
-        public Object[] getChildren(Object parentElement)
-        {
-            if (parentElement != null)
-            {
-                List<Object> children = new ArrayList<Object>();
-                if (parentElement instanceof SetAnnotations)
-                {
-                    children.addAll(((SetAnnotations) parentElement).getAnnotations());
-                }
-                else if (parentElement instanceof Annotation)
-                {
-                    children.addAll(((Annotation) parentElement).getAnnotations());
-                    children.addAll(((Annotation) parentElement).getAnnotationValues());
-                }
-                return children.toArray();
-            }
-            return null;
-        }
-
-        /**
-         * @see ITreeContentProvider#getParent()
-         */
-        @Override
-        public Object getParent(Object element)
-        {
-            return null;
-        }
-
-        /**
-         * @see ITreeContentProvider#hasChildren()
-         */
-        @Override
-        public boolean hasChildren(Object element)
-        {
-            return getChildren(element).length > 0;
-        }
-    }
-
-    /**
-     * ColumnLabelProvider for the column "name" of the treeViewer.
-     */
-    class TreeViewerLabelProviderName extends ColumnLabelProvider
-    {
-        /**
-         * @see ColumnLabelProvider#getImage(Object)
-         */
-        @Override
-        public Image getImage(Object element)
-        {
-            if (element instanceof Annotation)
-            {
-                return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.ANNOTATION_ICON_16).createImage();
-            }
-            else if (element instanceof AnnotationValue)
-            {
-                return Activator.getDefault().getImageDescriptor(SMILADesignerUIConstants.ANNOTATION_VALUE_ICON_16)
-                        .createImage();
-            }
-            else
-            {
-                return null;
-            }
-        }
-
-        /**
-         * @see ColumnLabelProvider#getText(Object)
-         */
-        @Override
-        public String getText(Object element)
-        {
-            if (element instanceof Annotation)
-            {
-                return ((Annotation) element).getName();
-            }
-            else if (element instanceof AnnotationValue)
-            {
-                return ((AnnotationValue) element).getName();
-            }
-            else
-            {
-                return null;
-            }
-        }
-    }
-
-    /**
-     * ColumnLabelProvider for the column "value" of the treeViewer.
-     */
-    class TreeViewerLabelProviderValue extends ColumnLabelProvider
-    {
-        /**
-         * @see ColumnLabelProvider#getImage(Object)
-         */
-        @Override
-        public Image getImage(Object element)
-        {
-            return null;
-        }
-
-        /**
-         * @see ColumnLabelProvider#getText(Object)
-         */
-        @Override
-        public String getText(Object element)
-        {
-            if (element instanceof AnnotationValue)
-            {
-                return ((AnnotationValue) element).getValue();
-            }
-            else
-            {
-                return null;
-            }
-        }
-    }
-
-    /**
-     * Extension of the class EditingSupport for use in the treeViewer (to make the columns editable).
-     */
-    public class TreeViewerEditingSupport extends EditingSupport
-    {
-        private final CellEditor cellEditor;
-        private int column;
-
-        /**
-         * Creates a new instance of {@link TreeViewerEditingSupport}
-         * 
-         * @param viewer The viewer for which columns the EditorSupport should be enabled
-         * @param column The column number on which this EditorSupport implementation should be applied
-         */
-        public TreeViewerEditingSupport(TreeViewer viewer, int column)
-        {
-            super(viewer);
-            this.column = column;
-            this.cellEditor = new TextCellEditor(viewer.getTree());
-        }
-
-        /**
-         * @see EditingSupport#canEdit(Object)
-         */
-        @Override
-        protected boolean canEdit(Object element)
-        {
-            if (element instanceof AnnotationValue || column == 0)
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        /**
-         * @see EditingSupport#getCellEditor(Object)
-         */
-        @Override
-        protected CellEditor getCellEditor(Object element)
-        {
-            return cellEditor;
-        }
-
-        /**
-         * @see EditingSupport#getValue(Object)
-         */
-        @Override
-        protected Object getValue(Object element)
-        {
-            if (element instanceof Annotation)
-            {
-                Annotation annotation = (Annotation) element;
-                if (column == 0)
-                {
-                    return annotation.getName();
-                }
-            }
-            else if (element instanceof AnnotationValue)
-            {
-                AnnotationValue annotationValue = (AnnotationValue) element;
-                if (column == 0)
-                {
-                    return annotationValue.getName();
-                }
-                else if (column == 1)
-                {
-                    return annotationValue.getValue();
-                }
-            }
-            return null;
-        }
-
-        /**
-         * @see EditingSupport#setValue(Object, Object)
-         */
-        @Override
-        protected void setValue(Object element, Object value)
-        {
-            if (value instanceof String && value != null)
-            {
-                if (element instanceof Annotation && column == 0)
-                {
-                    ((Annotation) element).setName((String) value);
-                }
-                else if (element instanceof AnnotationValue)
-                {
-                    if (column == 0)
-                    {
-                        ((AnnotationValue) element).setName((String) value);
-                    }
-                    else if (column == 1)
-                    {
-                        ((AnnotationValue) element).setValue((String) value);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * ColumnViewerEditorActivationStrategy for the treeViewer.
-     * Defines that the columns will be editable after a doubleclick on them.
-     */
-    class TreeViewerColumnViewerEditorActivationStrategy extends ColumnViewerEditorActivationStrategy
-    {
-        /**
-         * Creates a new instance of {@link TreeViewerColumnViewerEditorActivationStrategy}.
-         * 
-         * @param viewer The viewer on which this strategy should be used.
-         */
-        public TreeViewerColumnViewerEditorActivationStrategy(ColumnViewer viewer)
-        {
-            super(viewer);
-        }
-
-        /**
-         * @see ColumnViewerEditorActivationStrategy#isEditorActivationEvent(ColumnViewerEditorActivationEvent)
-         */
-        @Override
-        protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event)
-        {
-            MouseEvent mouseEvent = (MouseEvent) event.sourceEvent;
-            boolean singleSelect = ((IStructuredSelection) treeViewer.getSelection()).size() == 1;
-            boolean isLeftMouseDoubleSelect =
-                    event.eventType == ColumnViewerEditorActivationEvent.MOUSE_DOUBLE_CLICK_SELECTION && mouseEvent.button == 1;
-            return singleSelect
-                    && (isLeftMouseDoubleSelect || event.eventType == ColumnViewerEditorActivationEvent.PROGRAMMATIC
-                            || event.eventType == ColumnViewerEditorActivationEvent.TRAVERSAL || (event.eventType == ColumnViewerEditorActivationEvent.KEY_PRESSED && event.keyCode == SWT.CR));
-        }
-    }
-
-    /**
-     * SelectionListener for the menu of the treeViewer.
-     */
-    class MenuItemSelectionListener implements SelectionListener
-    {
-        @Override
-        public void widgetSelected(SelectionEvent e)
-        {
-            TreeItem treeItem = treeViewer.getTree().getSelection().length > 0 ? treeViewer.getTree().getSelection()[0] : null;
-            MenuItem menuItem = (MenuItem) e.getSource();
-
-            if (treeItem != null)
-            {
-                if (menuItem.getData() == menuActions.ADD_ANNOTATION)
-                {
-                    Annotation annotation = RecordFactory.eINSTANCE.createAnnotation();
-                    if (treeItem.getData() instanceof Annotation)
-                    {
-                        ((Annotation) treeItem.getData()).getAnnotations().add(annotation);
-                    }
-                    else if (treeItem.getData() instanceof AnnotationValue)
-                    {
-                        ((Annotation) treeItem.getParentItem().getData()).getAnnotations().add(annotation);
-                    }
-                }
-                else if (menuItem.getData() == menuActions.ADD_ANNOTATION_VALUE)
-                {
-                    AnnotationValue annotationValue = RecordFactory.eINSTANCE.createAnnotationValue();
-                    if (treeItem.getData() instanceof Annotation)
-                    {
-                        ((Annotation) treeItem.getData()).getAnnotationValues().add(annotationValue);
-                    }
-                    else if (treeItem.getData() instanceof AnnotationValue)
-                    {
-                        ((Annotation) treeItem.getParentItem().getData()).getAnnotationValues().add(annotationValue);
-                    }
-                }
-                else if (menuItem.getData() == menuActions.DELETE_ITEM)
-                {
-                    TreeItem treeItemParent = treeItem.getParentItem();
-                    if (treeItemParent != null)
-                    {
-                        if (treeItem.getData() instanceof Annotation)
-                        {
-                            if (treeItemParent.getData() instanceof Annotation)
-                            {
-                                ((Annotation) treeItemParent.getData()).getAnnotations().remove(treeItem.getData());
-                            }
-                        }
-                        else if (treeItem.getData() instanceof AnnotationValue)
-                        {
-                            ((Annotation) treeItemParent.getData()).getAnnotationValues().remove(treeItem.getData());
-                        }
-                    }
-                    else
-                    {
-                        ((SetAnnotations) treeItem.getParent().getData()).getAnnotations().remove(treeItem.getData());
-                    }
-                }
-            }
-            else if (menuItem.getData() == menuActions.ADD_ANNOTATION)
-            {
-                Annotation annotation = RecordFactory.eINSTANCE.createAnnotation();
-                ((SetAnnotations) treeViewer.getTree().getData()).getAnnotations().add(annotation);
-            }
-        }
-
-        @Override
-        public void widgetDefaultSelected(SelectionEvent e)
-        {
-            // Nothing to do
-        }
-    }
-
-    /**
-     * MouseListener for the {@link TreeViewer}.
-     */
-    class TreeViewerMouseListener implements MouseListener
-    {
-        /**
-         * @see MouseListener#mouseUp(MouseEvent)
-         */
-        @Override
-        public void mouseUp(MouseEvent e)
-        {
-            TreeItem treeItem = treeViewer.getTree().getItem(new Point(e.x, e.y));
-            if (treeItem != null)
-            {
-                if (treeItem.getData() instanceof AnnotationValue)
-                {
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION.index).setEnabled(false);
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION_VALUE.index).setEnabled(true);
-                    treeViewer.getTree().getMenu().getItem(menuActions.DELETE_ITEM.index).setEnabled(true);
-                }
-                else if (treeItem.getData() instanceof Annotation)
-                {
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION.index).setEnabled(true);
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION_VALUE.index).setEnabled(true);
-                    treeViewer.getTree().getMenu().getItem(menuActions.DELETE_ITEM.index).setEnabled(true);
-                }
-            }
-            else
-            {
-                if (treeViewer.getTree().getItems().length == 0)
-                {
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION.index).setEnabled(true);
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION_VALUE.index).setEnabled(false);
-                    treeViewer.getTree().getMenu().getItem(menuActions.DELETE_ITEM.index).setEnabled(false);
-                }
-                else
-                {
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION.index).setEnabled(false);
-                    treeViewer.getTree().getMenu().getItem(menuActions.ADD_ANNOTATION_VALUE.index).setEnabled(false);
-                    treeViewer.getTree().getMenu().getItem(menuActions.DELETE_ITEM.index).setEnabled(false);
-                }
-            }
-        }
-
-        /**
-         * @see MouseListener#mouseDown(MouseEvent)
-         */
-        @Override
-        public void mouseDown(MouseEvent e)
-        {
-            // Nothing to do
-        }
-
-        /**
-         * @see MouseListener#mouseDoubleClick(MouseEvent)
-         */
-        @Override
-        public void mouseDoubleClick(MouseEvent e)
-        {
-            // Nothing to do
-        }
-    }
-}
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_map.png b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_map.png
new file mode 100644
index 0000000..ca779f3
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_map.png
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_seq.png b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_seq.png
new file mode 100644
index 0000000..44084ad
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_seq.png
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_val.png b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_val.png
new file mode 100644
index 0000000..8b8b1ca
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/icon_val.png
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokePipelet.gif b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokePipelet.gif
deleted file mode 100644
index 1942eac..0000000
--- a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokePipelet.gif
+++ /dev/null
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokePipelet.png b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokePipelet.png
new file mode 100644
index 0000000..23b8281
--- /dev/null
+++ b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokePipelet.png
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokeService.gif b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokeService.gif
deleted file mode 100644
index b46e70e..0000000
--- a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj16/invokeService.gif
+++ /dev/null
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokePipelet.png b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokePipelet.png
index 9d1bc4f..52cf645 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokePipelet.png
+++ b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokePipelet.png
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokeService.png b/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokeService.png
deleted file mode 100644
index 9d1bc4f..0000000
--- a/tooling/org.eclipse.smila.processing.designer.ui/icons/obj20/invokeService.png
+++ /dev/null
Binary files differ
diff --git a/tooling/org.eclipse.smila.processing.designer.ui/plugin.xml b/tooling/org.eclipse.smila.processing.designer.ui/plugin.xml
index 97f0b58..b297aca 100644
--- a/tooling/org.eclipse.smila.processing.designer.ui/plugin.xml
+++ b/tooling/org.eclipse.smila.processing.designer.ui/plugin.xml
@@ -40,20 +40,6 @@
                 tab="org.eclipse.smila.processing.ui.tabs.configuration">
                 <input type="org.eclipse.smila.processing.designer.model.processor.InvokePipelet" />
             </propertySection>
-            <propertySection
-                  id="org.eclipse.smila.processing.designer.ui.properties.ServiceTypeSection"
-                  class="org.eclipse.smila.processing.designer.ui.properties.ServiceTypeSection"
-                  afterSection="org.eclipse.bpel.ui.sections.Name"
-                  tab="org.eclipse.bpel.ui.tabs.description">
-                <input type="org.eclipse.smila.processing.designer.model.processor.InvokeService" />
-            </propertySection>
-            <propertySection
-                  class="org.eclipse.smila.processing.designer.ui.properties.SetAnnotationsSection"
-                  id="org.eclipse.smila.processing.designer.ui.properties.SetAnnotationsSection"
-                  tab="org.eclipse.smila.processing.ui.tabs.configuration">
-               	  <input type="org.eclipse.smila.processing.designer.model.processor.InvokeService">
-               </input>
-            </propertySection>
         </propertySections>
     </extension>
     
@@ -63,10 +49,6 @@
             class="org.eclipse.smila.processing.designer.ui.factories.InvokePipeletUIFactory"
             specCompliant="false" categoryId="org.eclipse.smila"
             id="org.eclipse.smila.processing.designer.ui.factories.InvokePipeletUIFactory" />
-        <factory
-            class="org.eclipse.smila.processing.designer.ui.factories.InvokeServiceUIFactory"
-            specCompliant="false" categoryId="org.eclipse.smila"
-            id="org.eclipse.smila.processing.designer.ui.factories.InvokeServiceUIFactory" />
     </extension>
     
 </plugin>
