diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..815ba1e854717df57ececed802ea30f464a3ae28
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,26 @@
+
+
+*.class
+*.log
+
+# sbt
+dist/*
+target/
+lib_managed/
+src_managed/
+project/boot/
+project/plugins/project/
+
+# Scala-IDE
+.scala_dependencies
+
+# Eclipse
+.project
+.classpath
+.cache
+.cache-main
+.settings/
+
+# IntelliJ
+.idea/
+/bin/
diff --git a/.scalastyle b/.scalastyle
new file mode 100644
index 0000000000000000000000000000000000000000..bed4869082869eff37767049d56b09df30883dbe
--- /dev/null
+++ b/.scalastyle
@@ -0,0 +1 @@
+<scalastyle-project-configuration file="/ModelSyncProvider/support/scalastyle_config.xml" enabled="true"></scalastyle-project-configuration>
diff --git a/build.sbt b/build.sbt
new file mode 100644
index 0000000000000000000000000000000000000000..7ff0846f1b341182c4f03b51e9148bf753333478
--- /dev/null
+++ b/build.sbt
@@ -0,0 +1,15 @@
+import sbt.Keys.organization
+
+val scrollVersion = "1.8"
+
+lazy val modelmanagementprovider = (project in file(".")).
+  settings(
+    name := "ModelManagementProvider",
+    organization := "de.tu-dresden.inf.st",
+    version := "0.1",
+    scalaVersion := "2.12.8",
+    sbtVersion := "1.2.8",
+    libraryDependencies ++= Seq(
+        "com.github.max-leuthaeuser" %% "scroll" % scrollVersion)
+  )
+
diff --git a/lib/modeljoin.jar b/lib/modeljoin.jar
new file mode 100644
index 0000000000000000000000000000000000000000..7dd9eed4acaada106ddb92d3b771163185721b73
Binary files /dev/null and b/lib/modeljoin.jar differ
diff --git a/project/build.properties b/project/build.properties
new file mode 100644
index 0000000000000000000000000000000000000000..c0bab04941d74f9690e3610772090bfa4af33c37
--- /dev/null
+++ b/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.8
diff --git a/project/plugins.sbt b/project/plugins.sbt
new file mode 100644
index 0000000000000000000000000000000000000000..a4e6fcc87c3d3c84b38d39cf4ec86abd88e39c99
--- /dev/null
+++ b/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "5.2.4")
diff --git a/src/main/java/org/rosi_project/model_management/util/query/ModelJoinCreator.java b/src/main/java/org/rosi_project/model_management/util/query/ModelJoinCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..16881a09afc8c98dd37eaf3b35f14696be758ec0
--- /dev/null
+++ b/src/main/java/org/rosi_project/model_management/util/query/ModelJoinCreator.java
@@ -0,0 +1,93 @@
+package org.rosi_project.model_management.util.query;
+
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.attributes;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.naturalJoin;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.thetaJoin;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.outerJoin;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.outgoing;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.incoming;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.subtype;
+import static org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder.supertype;
+
+import java.io.File;
+
+import org.rosi_project.model_sync.model_join.representation.core.AttributePath;
+import org.rosi_project.model_sync.model_join.representation.core.ClassResource;
+import org.rosi_project.model_sync.model_join.representation.grammar.CompoundKeepBuilder;
+import org.rosi_project.model_sync.model_join.representation.grammar.KeepExpression;
+import org.rosi_project.model_sync.model_join.representation.grammar.ModelJoinExpression;
+import org.rosi_project.model_sync.model_join.representation.util.JoinFactory.AbstractJoinBuilder;
+import org.rosi_project.model_sync.model_join.representation.util.ModelJoinBuilder;
+import org.rosi_project.model_sync.model_join.representation.writer.FileBasedModelJoinWriter;
+
+public class ModelJoinCreator {
+
+	private AbstractJoinBuilder ajb = null;
+
+	public AbstractJoinBuilder createNaturalJoin(String start) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(start);
+		ajb = naturalJoin().join(classRessource).with(classRessource).as(classRessource);
+		return ajb;
+	}
+
+	public AbstractJoinBuilder createThetaJoin(String start, String condition) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(start);
+		ajb = thetaJoin().where(condition).join(classRessource).with(classRessource).as(classRessource);
+		return ajb;
+	}
+
+	public AbstractJoinBuilder createOuterJoin(String start, boolean left) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(start);
+		if (left) {
+			ajb = outerJoin().leftOuter().join(classRessource).with(classRessource).as(classRessource);
+		} else {
+			ajb = outerJoin().rightOuter().join(classRessource).with(classRessource).as(classRessource);
+		}
+		return ajb;
+	}
+
+	public void createAttribute(Object o, String ressourceName, String attrName) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(ressourceName);
+		AttributePath attrPath = AttributePath.from(classRessource, attrName);
+		KeepExpression ke = attributes(attrPath);
+		if (o instanceof AbstractJoinBuilder) {
+			((AbstractJoinBuilder) o).keep(ke);
+		}
+		if (o instanceof CompoundKeepBuilder) {
+			((CompoundKeepBuilder) o).keep(ke);
+		}
+	}
+
+	public CompoundKeepBuilder createOutgoingReference(String ressourceName, String attrName) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(ressourceName);
+		AttributePath attrPath = AttributePath.from(classRessource, attrName);
+		return outgoing(attrPath).as(classRessource);
+	}
+
+	public CompoundKeepBuilder createIncomingReference(String ressourceName, String attrName) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(ressourceName);
+		AttributePath attrPath = AttributePath.from(classRessource, attrName);
+		return incoming(attrPath).as(classRessource);
+	}
+
+	public CompoundKeepBuilder createSubType(String ressourceName) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(ressourceName);
+		return subtype(classRessource).as(classRessource);
+	}
+
+	public CompoundKeepBuilder createSuperType(String ressourceName) {
+		ClassResource classRessource = ClassResource.fromQualifiedName(ressourceName);
+		return supertype(classRessource).as(classRessource);
+	}
+
+	public void createFile(String fileName) {
+		if (ajb != null) {
+			ModelJoinExpression modelJoin = ModelJoinBuilder.createNewModelJoin().add(ajb.done()).build();
+
+			File file = new File(fileName);
+
+			FileBasedModelJoinWriter writer = new FileBasedModelJoinWriter(file);
+			writer.write(modelJoin);
+		}
+	}
+}
diff --git a/src/main/scala/aml/Attribute.scala b/src/main/scala/aml/Attribute.scala
new file mode 100644
index 0000000000000000000000000000000000000000..dc630421afd52270511b90d386dfa1459b696d59
--- /dev/null
+++ b/src/main/scala/aml/Attribute.scala
@@ -0,0 +1,21 @@
+package aml
+
+class Attribute(protected var value: String, c_Name: String, c_Id: String) extends CAEXObject(c_Name, c_Id) {
+
+  def getValue(): String = {
+    value
+  }
+
+  def setValue(v: String): Unit = {
+    value = v
+  }
+
+  override def toString(): String = {
+    "Attribute:" + " value=" + value + " name=" + name + " id=" + id
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/CAEXObject.scala b/src/main/scala/aml/CAEXObject.scala
new file mode 100644
index 0000000000000000000000000000000000000000..7f02fc6e9935ec4dd3f20617fae521cbc1ababe1
--- /dev/null
+++ b/src/main/scala/aml/CAEXObject.scala
@@ -0,0 +1,29 @@
+package aml
+
+abstract class CAEXObject(protected var name: String, protected var id: String) {
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  def getId(): String = {
+    id
+  }
+
+  def setId(i: String): Unit = {
+    id = i
+  }
+
+  override def toString(): String = {
+    "CAEXObject:" + " name=" + name + " id=" + id
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/HelperCAEXObject.scala b/src/main/scala/aml/HelperCAEXObject.scala
new file mode 100644
index 0000000000000000000000000000000000000000..8243a4a51f90f67a113c8e0c850b68438562d070
--- /dev/null
+++ b/src/main/scala/aml/HelperCAEXObject.scala
@@ -0,0 +1,19 @@
+package aml
+
+import org.rosi_project.model_management.sum.query.QueryHelper
+
+class HelperCAEXObject(c_Name: String, c_Id: String) extends CAEXObject(c_Name, c_Id) with QueryHelper {
+
+  override def equals(that: Any): Boolean = {
+    that.isInstanceOf[CAEXObject]
+  }
+
+  override def toString(): String = {
+    "HelperCAEXObject:" + " name=" + name + " id=" + id
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/InstanceHierarchy.scala b/src/main/scala/aml/InstanceHierarchy.scala
new file mode 100644
index 0000000000000000000000000000000000000000..defa7a9f9b60883d4164bc976994d6e8ae62b839
--- /dev/null
+++ b/src/main/scala/aml/InstanceHierarchy.scala
@@ -0,0 +1,13 @@
+package aml
+
+class InstanceHierarchy(c_Name: String, c_Id: String) extends CAEXObject(c_Name, c_Id) {
+
+  override def toString(): String = {
+    "InstanceHierarchy:" + " name=" + name + " id=" + id
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/InstanceHierarchyInternalElementsInternalElement.scala b/src/main/scala/aml/InstanceHierarchyInternalElementsInternalElement.scala
new file mode 100644
index 0000000000000000000000000000000000000000..30e6d671b7ea5b29e073c7cfb6f4d8cdf4d1a794
--- /dev/null
+++ b/src/main/scala/aml/InstanceHierarchyInternalElementsInternalElement.scala
@@ -0,0 +1,46 @@
+package aml
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class InstanceHierarchyInternalElementsInternalElement(private val sInstance: InstanceHierarchy, private val tInstance: InternalElement) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[InstanceHierarchyInternalElementsInternalElement " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): InstanceHierarchy = {
+    return sInstance
+  }
+
+  def getTargetIns(): InternalElement = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/InternalElement.scala b/src/main/scala/aml/InternalElement.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a541add7cf00495b649278149060dcfe3319c7b4
--- /dev/null
+++ b/src/main/scala/aml/InternalElement.scala
@@ -0,0 +1,13 @@
+package aml
+
+class InternalElement(s_Name: String, s_Id: String) extends SystemUnitClass(s_Name, s_Id) {
+
+  override def toString(): String = {
+    "InternalElement:" + " name=" + name + " id=" + id
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/InternalElementBaseSystemUnitSystemUnitClass.scala b/src/main/scala/aml/InternalElementBaseSystemUnitSystemUnitClass.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c16498184824d6d9c485aa6f8b18affec8fd8d27
--- /dev/null
+++ b/src/main/scala/aml/InternalElementBaseSystemUnitSystemUnitClass.scala
@@ -0,0 +1,46 @@
+package aml
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class InternalElementBaseSystemUnitSystemUnitClass(private val sInstance: InternalElement, private val tInstance: SystemUnitClass) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[InternalElementBaseSystemUnitSystemUnitClass " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): InternalElement = {
+    return sInstance
+  }
+
+  def getTargetIns(): SystemUnitClass = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/SystemUnitClass.scala b/src/main/scala/aml/SystemUnitClass.scala
new file mode 100644
index 0000000000000000000000000000000000000000..fb8d0c9dddd13252c1d6a6f7c534018afeab9173
--- /dev/null
+++ b/src/main/scala/aml/SystemUnitClass.scala
@@ -0,0 +1,13 @@
+package aml
+
+class SystemUnitClass(c_Name: String, c_Id: String) extends CAEXObject(c_Name, c_Id) {
+
+  override def toString(): String = {
+    "SystemUnitClass:" + " name=" + name + " id=" + id
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/SystemUnitClassAttributesAttribute.scala b/src/main/scala/aml/SystemUnitClassAttributesAttribute.scala
new file mode 100644
index 0000000000000000000000000000000000000000..69478d9bbb40b0bb5af9cce8d91a1468279d052d
--- /dev/null
+++ b/src/main/scala/aml/SystemUnitClassAttributesAttribute.scala
@@ -0,0 +1,46 @@
+package aml
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class SystemUnitClassAttributesAttribute(private val sInstance: SystemUnitClass, private val tInstance: Attribute) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[SystemUnitClassAttributesAttribute " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): SystemUnitClass = {
+    return sInstance
+  }
+
+  def getTargetIns(): Attribute = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/aml/SystemUnitClassInternalElementsInternalElement.scala b/src/main/scala/aml/SystemUnitClassInternalElementsInternalElement.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a75d7c91dd8b97b07984a988373288ea15b3fabb
--- /dev/null
+++ b/src/main/scala/aml/SystemUnitClassInternalElementsInternalElement.scala
@@ -0,0 +1,46 @@
+package aml
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class SystemUnitClassInternalElementsInternalElement(private val sInstance: SystemUnitClass, private val tInstance: InternalElement) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[SystemUnitClassInternalElementsInternalElement " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): SystemUnitClass = {
+    return sInstance
+  }
+
+  def getTargetIns(): InternalElement = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/AudioVisualItem.scala b/src/main/scala/elib/AudioVisualItem.scala
new file mode 100644
index 0000000000000000000000000000000000000000..24bba4c51f93a733f088d01630cc44baf69a06de
--- /dev/null
+++ b/src/main/scala/elib/AudioVisualItem.scala
@@ -0,0 +1,39 @@
+package elib
+
+import java.util.Date
+
+class AudioVisualItem(protected var damaged: Boolean, protected var minutesLength: Int, protected var title: String, c_PublicationDate: Date) extends CirculatingItem(c_PublicationDate) {
+
+  def getDamaged(): Boolean = {
+    damaged
+  }
+
+  def setDamaged(d: Boolean): Unit = {
+    damaged = d
+  }
+
+  def getMinutesLength(): Int = {
+    minutesLength
+  }
+
+  def setMinutesLength(m: Int): Unit = {
+    minutesLength = m
+  }
+
+  def getTitle(): String = {
+    title
+  }
+
+  def setTitle(t: String): Unit = {
+    title = t
+  }
+
+  override def toString(): String = {
+    "AudioVisualItem:" + " damaged=" + damaged + " minutesLength=" + minutesLength + " title=" + title + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Book.scala b/src/main/scala/elib/Book.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a067844d35e80b7fac16ebe54351c070e4296eb7
--- /dev/null
+++ b/src/main/scala/elib/Book.scala
@@ -0,0 +1,39 @@
+package elib
+
+import java.util.Date
+
+class Book(protected var category: BookCategory.Value, protected var pages: Int, protected var title: String, c_PublicationDate: Date) extends CirculatingItem(c_PublicationDate) {
+
+  def getCategory(): BookCategory.Value = {
+    category
+  }
+
+  def setCategory(c: BookCategory.Value): Unit = {
+    category = c
+  }
+
+  def getPages(): Int = {
+    pages
+  }
+
+  def setPages(p: Int): Unit = {
+    pages = p
+  }
+
+  def getTitle(): String = {
+    title
+  }
+
+  def setTitle(t: String): Unit = {
+    title = t
+  }
+
+  override def toString(): String = {
+    "Book:" + " category=" + category + " pages=" + pages + " title=" + title + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/BookAuthorWriter.scala b/src/main/scala/elib/BookAuthorWriter.scala
new file mode 100644
index 0000000000000000000000000000000000000000..9e73dffb96c89bffc7523c2ff9eca09b373e8c92
--- /dev/null
+++ b/src/main/scala/elib/BookAuthorWriter.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IAssociation
+
+class BookAuthorWriter(private val sInstance: Book, private val tInstance: Writer) extends IAssociation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[BookAuthorWriter " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Book = {
+    return sInstance
+  }
+
+  def getTargetIns(): Writer = {
+    return tInstance
+  }
+
+  class Source extends IAssociationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IAssociationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/BookCategory.scala b/src/main/scala/elib/BookCategory.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2992844caa1cab7faf8d8722477e55317d53ea0b
--- /dev/null
+++ b/src/main/scala/elib/BookCategory.scala
@@ -0,0 +1,8 @@
+package elib
+
+object BookCategory extends Enumeration {
+
+  val Mystery, ScienceFiction, Biography = Value
+}
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/BookOnTape.scala b/src/main/scala/elib/BookOnTape.scala
new file mode 100644
index 0000000000000000000000000000000000000000..bcd751a16a83bc66569ab40c622e509542b43997
--- /dev/null
+++ b/src/main/scala/elib/BookOnTape.scala
@@ -0,0 +1,15 @@
+package elib
+
+import java.util.Date
+
+class BookOnTape(a_Damaged: Boolean, a_MinutesLength: Int, a_Title: String, a_PublicationDate: Date) extends AudioVisualItem(a_Damaged, a_MinutesLength, a_Title, a_PublicationDate) {
+
+  override def toString(): String = {
+    "BookOnTape:" + " damaged=" + damaged + " minutesLength=" + minutesLength + " title=" + title + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/BookOnTapeAuthorWriter.scala b/src/main/scala/elib/BookOnTapeAuthorWriter.scala
new file mode 100644
index 0000000000000000000000000000000000000000..87c95599717f5c8c7c55ce59f4f8ef0cc4d8c188
--- /dev/null
+++ b/src/main/scala/elib/BookOnTapeAuthorWriter.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class BookOnTapeAuthorWriter(private val sInstance: BookOnTape, private val tInstance: Writer) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[BookOnTapeAuthorWriter " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): BookOnTape = {
+    return sInstance
+  }
+
+  def getTargetIns(): Writer = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/BookOnTapeReaderPerson.scala b/src/main/scala/elib/BookOnTapeReaderPerson.scala
new file mode 100644
index 0000000000000000000000000000000000000000..68b29a225661aa874097dfeb0d866a6f54e1f3f3
--- /dev/null
+++ b/src/main/scala/elib/BookOnTapeReaderPerson.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class BookOnTapeReaderPerson(private val sInstance: BookOnTape, private val tInstance: Person) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[BookOnTapeReaderPerson " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): BookOnTape = {
+    return sInstance
+  }
+
+  def getTargetIns(): Person = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Borrower.scala b/src/main/scala/elib/Borrower.scala
new file mode 100644
index 0000000000000000000000000000000000000000..b28d61757e82a47f9165ef1e9136a2b5bcaa19b8
--- /dev/null
+++ b/src/main/scala/elib/Borrower.scala
@@ -0,0 +1,13 @@
+package elib
+
+class Borrower(p_LastName: String, p_FirstName: String) extends Person(p_LastName, p_FirstName) {
+
+  override def toString(): String = {
+    "Borrower:" + " lastName=" + lastName + " firstName=" + firstName
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/CirculatingItem.scala b/src/main/scala/elib/CirculatingItem.scala
new file mode 100644
index 0000000000000000000000000000000000000000..7678b10f8f4661d868efaf58637c496663913202
--- /dev/null
+++ b/src/main/scala/elib/CirculatingItem.scala
@@ -0,0 +1,15 @@
+package elib
+
+import java.util.Date
+
+class CirculatingItem(i_PublicationDate: Date) extends Item(i_PublicationDate) {
+
+  override def toString(): String = {
+    "CirculatingItem:" + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Employee.scala b/src/main/scala/elib/Employee.scala
new file mode 100644
index 0000000000000000000000000000000000000000..204e8cf16f5ed6462f4ad7b2cc49a3ef7b13f6be
--- /dev/null
+++ b/src/main/scala/elib/Employee.scala
@@ -0,0 +1,13 @@
+package elib
+
+class Employee(p_LastName: String, p_FirstName: String) extends Person(p_LastName, p_FirstName) {
+
+  override def toString(): String = {
+    "Employee:" + " lastName=" + lastName + " firstName=" + firstName
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/EmployeeManagerEmployee.scala b/src/main/scala/elib/EmployeeManagerEmployee.scala
new file mode 100644
index 0000000000000000000000000000000000000000..929435856853b6cb8f403b820323e1b020399d54
--- /dev/null
+++ b/src/main/scala/elib/EmployeeManagerEmployee.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class EmployeeManagerEmployee(private val sInstance: Employee, private val tInstance: Employee) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[EmployeeManagerEmployee " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Employee = {
+    return sInstance
+  }
+
+  def getTargetIns(): Employee = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Item.scala b/src/main/scala/elib/Item.scala
new file mode 100644
index 0000000000000000000000000000000000000000..cafa10ba239c7bee10438d8c4103b47790893a34
--- /dev/null
+++ b/src/main/scala/elib/Item.scala
@@ -0,0 +1,23 @@
+package elib
+
+import java.util.Date
+
+class Item(protected var publicationDate: Date) {
+
+  def getPublicationDate(): Date = {
+    publicationDate
+  }
+
+  def setPublicationDate(p: Date): Unit = {
+    publicationDate = p
+  }
+
+  override def toString(): String = {
+    "Item:" + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Library.scala b/src/main/scala/elib/Library.scala
new file mode 100644
index 0000000000000000000000000000000000000000..e125115b0d8c92cb7235bc1a689a1f89f4ec634b
--- /dev/null
+++ b/src/main/scala/elib/Library.scala
@@ -0,0 +1,21 @@
+package elib
+
+class Library(protected var name: String) {
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  override def toString(): String = {
+    "Library:" + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryBooksBook.scala b/src/main/scala/elib/LibraryBooksBook.scala
new file mode 100644
index 0000000000000000000000000000000000000000..4b3cdd74ca78b317fed9ac77b32240f88a1028a2
--- /dev/null
+++ b/src/main/scala/elib/LibraryBooksBook.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class LibraryBooksBook(private val sInstance: Library, private val tInstance: Book) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryBooksBook " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Book = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryBorrowersBorrower.scala b/src/main/scala/elib/LibraryBorrowersBorrower.scala
new file mode 100644
index 0000000000000000000000000000000000000000..fe90ec4f95d4f277bf1e9b743b46e5a1c2bbb1c6
--- /dev/null
+++ b/src/main/scala/elib/LibraryBorrowersBorrower.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class LibraryBorrowersBorrower(private val sInstance: Library, private val tInstance: Borrower) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryBorrowersBorrower " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Borrower = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryBranchesLibrary.scala b/src/main/scala/elib/LibraryBranchesLibrary.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2a9ae9790200a836d8037864264cc1b50693a0c4
--- /dev/null
+++ b/src/main/scala/elib/LibraryBranchesLibrary.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class LibraryBranchesLibrary(private val sInstance: Library, private val tInstance: Library) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryBranchesLibrary " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Library = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryEmployeesEmployee.scala b/src/main/scala/elib/LibraryEmployeesEmployee.scala
new file mode 100644
index 0000000000000000000000000000000000000000..01e6d9f91fe2510b94976da0528fb6740df5fbfe
--- /dev/null
+++ b/src/main/scala/elib/LibraryEmployeesEmployee.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class LibraryEmployeesEmployee(private val sInstance: Library, private val tInstance: Employee) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryEmployeesEmployee " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Employee = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryParentBranchLibrary.scala b/src/main/scala/elib/LibraryParentBranchLibrary.scala
new file mode 100644
index 0000000000000000000000000000000000000000..1ad536c7323c06b0961e68137c44f84ea56e2a40
--- /dev/null
+++ b/src/main/scala/elib/LibraryParentBranchLibrary.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class LibraryParentBranchLibrary(private val sInstance: Library, private val tInstance: Library) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryParentBranchLibrary " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Library = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryStockItem.scala b/src/main/scala/elib/LibraryStockItem.scala
new file mode 100644
index 0000000000000000000000000000000000000000..148fdc00461d096de1187a827994a32f01a2e212
--- /dev/null
+++ b/src/main/scala/elib/LibraryStockItem.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class LibraryStockItem(private val sInstance: Library, private val tInstance: Item) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryStockItem " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Item = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/LibraryWritersWriter.scala b/src/main/scala/elib/LibraryWritersWriter.scala
new file mode 100644
index 0000000000000000000000000000000000000000..41f420e1d95b2c1346ac54ff3203bbd8ef148aa8
--- /dev/null
+++ b/src/main/scala/elib/LibraryWritersWriter.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class LibraryWritersWriter(private val sInstance: Library, private val tInstance: Writer) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryWritersWriter " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Writer = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Periodical.scala b/src/main/scala/elib/Periodical.scala
new file mode 100644
index 0000000000000000000000000000000000000000..8f2cbbf41d194ce964a53dab5b8f82d5fc845961
--- /dev/null
+++ b/src/main/scala/elib/Periodical.scala
@@ -0,0 +1,31 @@
+package elib
+
+import java.util.Date
+
+class Periodical(protected var issuesPerYear: Int, protected var title: String, i_PublicationDate: Date) extends Item(i_PublicationDate) {
+
+  def getIssuesPerYear(): Int = {
+    issuesPerYear
+  }
+
+  def setIssuesPerYear(i: Int): Unit = {
+    issuesPerYear = i
+  }
+
+  def getTitle(): String = {
+    title
+  }
+
+  def setTitle(t: String): Unit = {
+    title = t
+  }
+
+  override def toString(): String = {
+    "Periodical:" + " issuesPerYear=" + issuesPerYear + " title=" + title + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Person.scala b/src/main/scala/elib/Person.scala
new file mode 100644
index 0000000000000000000000000000000000000000..b2680a00deb4f3df8ce0574fb6dfc89781c6b77e
--- /dev/null
+++ b/src/main/scala/elib/Person.scala
@@ -0,0 +1,29 @@
+package elib
+
+class Person(protected var lastName: String, protected var firstName: String) {
+
+  def getLastName(): String = {
+    lastName
+  }
+
+  def setLastName(l: String): Unit = {
+    lastName = l
+  }
+
+  def getFirstName(): String = {
+    firstName
+  }
+
+  def setFirstName(f: String): Unit = {
+    firstName = f
+  }
+
+  override def toString(): String = {
+    "Person:" + " lastName=" + lastName + " firstName=" + firstName
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/VideoCassette.scala b/src/main/scala/elib/VideoCassette.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a43e3ab551e6daf945c9600680d7068e6bdf5845
--- /dev/null
+++ b/src/main/scala/elib/VideoCassette.scala
@@ -0,0 +1,15 @@
+package elib
+
+import java.util.Date
+
+class VideoCassette(a_Damaged: Boolean, a_MinutesLength: Int, a_Title: String, a_PublicationDate: Date) extends AudioVisualItem(a_Damaged, a_MinutesLength, a_Title, a_PublicationDate) {
+
+  override def toString(): String = {
+    "VideoCassette:" + " damaged=" + damaged + " minutesLength=" + minutesLength + " title=" + title + " publicationDate=" + publicationDate
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/VideoCassetteCastPerson.scala b/src/main/scala/elib/VideoCassetteCastPerson.scala
new file mode 100644
index 0000000000000000000000000000000000000000..5705c4e5aba9086f8778d120646c1ebefd87c4a4
--- /dev/null
+++ b/src/main/scala/elib/VideoCassetteCastPerson.scala
@@ -0,0 +1,46 @@
+package elib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class VideoCassetteCastPerson(private val sInstance: VideoCassette, private val tInstance: Person) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[VideoCassetteCastPerson " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): VideoCassette = {
+    return sInstance
+  }
+
+  def getTargetIns(): Person = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/elib/Writer.scala b/src/main/scala/elib/Writer.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c36a8bb35bc9eed7a8a3d22b5bc1d89fb5787382
--- /dev/null
+++ b/src/main/scala/elib/Writer.scala
@@ -0,0 +1,21 @@
+package elib
+
+class Writer(protected var name: String, p_LastName: String, p_FirstName: String) extends Person(p_LastName, p_FirstName) {
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  override def toString(): String = {
+    "Writer:" + " name=" + name + " lastName=" + lastName + " firstName=" + firstName
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/Actor.scala b/src/main/scala/imdbdatabase/Actor.scala
new file mode 100644
index 0000000000000000000000000000000000000000..e74c8f6d3235f06045f1d290be9716da546e05a8
--- /dev/null
+++ b/src/main/scala/imdbdatabase/Actor.scala
@@ -0,0 +1,13 @@
+package imdbdatabase
+
+class Actor(p_Dob: Double, p_Name: String) extends Person(p_Dob, p_Name) {
+
+  override def toString(): String = {
+    "Actor:" + " dob=" + dob + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/Figure.scala b/src/main/scala/imdbdatabase/Figure.scala
new file mode 100644
index 0000000000000000000000000000000000000000..26045a3a19a1032b595c67fcfc69117fdc2fbe80
--- /dev/null
+++ b/src/main/scala/imdbdatabase/Figure.scala
@@ -0,0 +1,21 @@
+package imdbdatabase
+
+class Figure(protected var name: String) {
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  override def toString(): String = {
+    "Figure:" + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/FigurePlayedByActor.scala b/src/main/scala/imdbdatabase/FigurePlayedByActor.scala
new file mode 100644
index 0000000000000000000000000000000000000000..05e24d36bdead47f659fe76ee47631351596f1e0
--- /dev/null
+++ b/src/main/scala/imdbdatabase/FigurePlayedByActor.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IAssociation
+
+class FigurePlayedByActor(private val sInstance: Figure, private val tInstance: Actor) extends IAssociation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[FigurePlayedByActor " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Figure = {
+    return sInstance
+  }
+
+  def getTargetIns(): Actor = {
+    return tInstance
+  }
+
+  class Source extends IAssociationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IAssociationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/Film.scala b/src/main/scala/imdbdatabase/Film.scala
new file mode 100644
index 0000000000000000000000000000000000000000..6c46b54768a12ebefc44aebbe930b4b7aacbdd5e
--- /dev/null
+++ b/src/main/scala/imdbdatabase/Film.scala
@@ -0,0 +1,29 @@
+package imdbdatabase
+
+class Film(protected var year: Int, protected var title: String) {
+
+  def getYear(): Int = {
+    year
+  }
+
+  def setYear(y: Int): Unit = {
+    year = y
+  }
+
+  def getTitle(): String = {
+    title
+  }
+
+  def setTitle(t: String): Unit = {
+    title = t
+  }
+
+  override def toString(): String = {
+    "Film:" + " year=" + year + " title=" + title
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/FilmFiguresFigure.scala b/src/main/scala/imdbdatabase/FilmFiguresFigure.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c50f8ea222bc918d5a9e09060c648226f7dcee53
--- /dev/null
+++ b/src/main/scala/imdbdatabase/FilmFiguresFigure.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IComposition
+
+class FilmFiguresFigure(private val sInstance: Film, private val tInstance: Figure) extends IComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[FilmFiguresFigure " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Film = {
+    return sInstance
+  }
+
+  def getTargetIns(): Figure = {
+    return tInstance
+  }
+
+  class Source extends ICompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends ICompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/IMDB.scala b/src/main/scala/imdbdatabase/IMDB.scala
new file mode 100644
index 0000000000000000000000000000000000000000..0da0fd891e4ff5ee32b824100566a82b298b54f7
--- /dev/null
+++ b/src/main/scala/imdbdatabase/IMDB.scala
@@ -0,0 +1,13 @@
+package imdbdatabase
+
+class IMDB {
+
+  override def toString(): String = {
+    "IMDB:"
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/IMDBActorsActor.scala b/src/main/scala/imdbdatabase/IMDBActorsActor.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2dd4a61be441fa9deadbec12585736360bb3e676
--- /dev/null
+++ b/src/main/scala/imdbdatabase/IMDBActorsActor.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IComposition
+
+class IMDBActorsActor(private val sInstance: IMDB, private val tInstance: Actor) extends IComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[IMDBActorsActor " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): IMDB = {
+    return sInstance
+  }
+
+  def getTargetIns(): Actor = {
+    return tInstance
+  }
+
+  class Source extends ICompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends ICompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/IMDBFilmsFilm.scala b/src/main/scala/imdbdatabase/IMDBFilmsFilm.scala
new file mode 100644
index 0000000000000000000000000000000000000000..96162d0225560b3b8f546d9926c7d6d94844eebb
--- /dev/null
+++ b/src/main/scala/imdbdatabase/IMDBFilmsFilm.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IComposition
+
+class IMDBFilmsFilm(private val sInstance: IMDB, private val tInstance: Film) extends IComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[IMDBFilmsFilm " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): IMDB = {
+    return sInstance
+  }
+
+  def getTargetIns(): Film = {
+    return tInstance
+  }
+
+  class Source extends ICompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends ICompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/IMDBUsersUser.scala b/src/main/scala/imdbdatabase/IMDBUsersUser.scala
new file mode 100644
index 0000000000000000000000000000000000000000..e901a63144cab744b3b5c9f68e231c734b47b620
--- /dev/null
+++ b/src/main/scala/imdbdatabase/IMDBUsersUser.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IComposition
+
+class IMDBUsersUser(private val sInstance: IMDB, private val tInstance: User) extends IComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[IMDBUsersUser " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): IMDB = {
+    return sInstance
+  }
+
+  def getTargetIns(): User = {
+    return tInstance
+  }
+
+  class Source extends ICompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends ICompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/IMDBVotesVote.scala b/src/main/scala/imdbdatabase/IMDBVotesVote.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2154984607c264fbf47b8a172ad8161b45c7904b
--- /dev/null
+++ b/src/main/scala/imdbdatabase/IMDBVotesVote.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IComposition
+
+class IMDBVotesVote(private val sInstance: IMDB, private val tInstance: Vote) extends IComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[IMDBVotesVote " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): IMDB = {
+    return sInstance
+  }
+
+  def getTargetIns(): Vote = {
+    return tInstance
+  }
+
+  class Source extends ICompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends ICompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/Person.scala b/src/main/scala/imdbdatabase/Person.scala
new file mode 100644
index 0000000000000000000000000000000000000000..39bc4a46c923c5ff4453586a4e1b3da8cc59ecc2
--- /dev/null
+++ b/src/main/scala/imdbdatabase/Person.scala
@@ -0,0 +1,29 @@
+package imdbdatabase
+
+class Person(protected var dob: Double, protected var name: String) {
+
+  def getDob(): Double = {
+    dob
+  }
+
+  def setDob(d: Double): Unit = {
+    dob = d
+  }
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  override def toString(): String = {
+    "Person:" + " dob=" + dob + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/User.scala b/src/main/scala/imdbdatabase/User.scala
new file mode 100644
index 0000000000000000000000000000000000000000..ff94ad98b7f2f6c93846b81f8b43bec17b7b0e39
--- /dev/null
+++ b/src/main/scala/imdbdatabase/User.scala
@@ -0,0 +1,29 @@
+package imdbdatabase
+
+class User(protected var email: String, protected var userName: String, p_Dob: Double, p_Name: String) extends Person(p_Dob, p_Name) {
+
+  def getEmail(): String = {
+    email
+  }
+
+  def setEmail(e: String): Unit = {
+    email = e
+  }
+
+  def getUserName(): String = {
+    userName
+  }
+
+  def setUserName(u: String): Unit = {
+    userName = u
+  }
+
+  override def toString(): String = {
+    "User:" + " email=" + email + " userName=" + userName + " dob=" + dob + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/Vote.scala b/src/main/scala/imdbdatabase/Vote.scala
new file mode 100644
index 0000000000000000000000000000000000000000..6187ae8c94fc0030fdf3e03e3c344f78631f5ddf
--- /dev/null
+++ b/src/main/scala/imdbdatabase/Vote.scala
@@ -0,0 +1,21 @@
+package imdbdatabase
+
+class Vote(protected var score: Int) {
+
+  def getScore(): Int = {
+    score
+  }
+
+  def setScore(s: Int): Unit = {
+    score = s
+  }
+
+  override def toString(): String = {
+    "Vote:" + " score=" + score
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/VoteFilmFilm.scala b/src/main/scala/imdbdatabase/VoteFilmFilm.scala
new file mode 100644
index 0000000000000000000000000000000000000000..42967397be4052251392ec7cafd22b6393d7257d
--- /dev/null
+++ b/src/main/scala/imdbdatabase/VoteFilmFilm.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IAssociation
+
+class VoteFilmFilm(private val sInstance: Vote, private val tInstance: Film) extends IAssociation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[VoteFilmFilm " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Vote = {
+    return sInstance
+  }
+
+  def getTargetIns(): Film = {
+    return tInstance
+  }
+
+  class Source extends IAssociationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IAssociationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/imdbdatabase/VoteUserUser.scala b/src/main/scala/imdbdatabase/VoteUserUser.scala
new file mode 100644
index 0000000000000000000000000000000000000000..dc9189f7e75bde9578c48cf11e0adedf8ea995df
--- /dev/null
+++ b/src/main/scala/imdbdatabase/VoteUserUser.scala
@@ -0,0 +1,46 @@
+package imdbdatabase
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class VoteUserUser(private val sInstance: Vote, private val tInstance: User) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[VoteUserUser " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Vote = {
+    return sInstance
+  }
+
+  def getTargetIns(): User = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/joins/JoinMovie.scala b/src/main/scala/joins/JoinMovie.scala
new file mode 100644
index 0000000000000000000000000000000000000000..5d4fde4cc00a621f9748de26b90ce2c2630299c8
--- /dev/null
+++ b/src/main/scala/joins/JoinMovie.scala
@@ -0,0 +1,83 @@
+package joins
+
+import org.rosi_project.model_management.sum.join.IJoinCompartment
+import imdbdatabase.Film
+import elib.VideoCassette
+import org.rosi_project.model_management.sum.join.IJoinInfo
+import java.util.Date
+
+class JoinMovie(private val base: Film, private val other: VideoCassette) extends IJoinCompartment {
+
+  initialize(base, other)
+
+  def getJoinInfo(): IJoinInfo = {
+    JoinMovieObject
+  }
+
+  def getTitle(): String = {
+    +baseRole getTitle ()
+  }
+
+  def setTitleView(title: String): Unit = {
+    +baseRole setTitle (title)
+    if (otherObj != null) {
+      +otherRole setTitle (title)
+    }
+  }
+
+  def getYear(): Int = {
+    +baseRole getYear ()
+  }
+
+  def setYear(year: Int): Unit = {
+    +baseRole setYear (year)
+  }
+
+  def getDamaged(): Boolean = {
+    if (otherObj != null) {
+      return +otherRole getDamaged ()
+    }
+    return false
+  }
+
+  def setDamagedView(damaged: Boolean): Unit = {
+    if (otherObj != null) {
+      +otherRole setDamaged (damaged)
+    }
+  }
+
+  def getMinutesLength(): Int = {
+    if (otherObj != null) {
+      return +otherRole getMinutesLength ()
+    }
+    return 0
+  }
+
+  def setMinutesLengthView(minuteslength: Int): Unit = {
+    if (otherObj != null) {
+      +otherRole setMinutesLength (minuteslength)
+    }
+  }
+
+  def getPublicationDate(): Date = {
+    if (otherObj != null) {
+      return +otherRole getPublicationDate ()
+    }
+    return null
+  }
+
+  def setPublicationDateView(publicationdate: Date): Unit = {
+    if (otherObj != null) {
+      +otherRole setPublicationDate (publicationdate)
+    }
+  }
+
+  override def toString(): String = {
+    "JOIN JoinMovie: " + baseObj + " " + otherObj
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/joins/JoinMovieObject.scala b/src/main/scala/joins/JoinMovieObject.scala
new file mode 100644
index 0000000000000000000000000000000000000000..38741d4613159269daaca5f5cfa6153c23a16cdc
--- /dev/null
+++ b/src/main/scala/joins/JoinMovieObject.scala
@@ -0,0 +1,47 @@
+package joins
+
+import org.rosi_project.model_management.sum.join.IJoinCompartment
+import org.rosi_project.model_management.sum.join.RsumJoinType
+import imdbdatabase.Film
+import elib.VideoCassette
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+object JoinMovieObject extends IJoinInfo {
+
+  def getJoinType(): RsumJoinType.Value = {
+    RsumJoinType.natural
+  }
+
+  def isInstanceBaseModel(obj: Object): Boolean = {
+    obj.isInstanceOf[Film]
+  }
+
+  def isInstanceOtherModel(obj: Object): Boolean = {
+    obj.isInstanceOf[VideoCassette]
+  }
+
+  def getNewInstance(b: Object, o: Object): IJoinCompartment = {
+    val j = new JoinMovie(null, null)
+    objectInitialize(j, b, o)
+    j
+  }
+
+  def isInstanceOf(obj: Object): Boolean = {
+    obj.isInstanceOf[JoinMovie]
+  }
+
+  def matchTwoObjects(b: Object, o: Object): Boolean = {
+    val base = b.asInstanceOf[Film]
+    val other = o.asInstanceOf[VideoCassette]
+    base.getTitle() == other.getTitle()
+  }
+
+  override def toString(): String = {
+    "JoinMovieObject"
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/lib/Employee.scala b/src/main/scala/lib/Employee.scala
new file mode 100644
index 0000000000000000000000000000000000000000..3d85776bccc4b2465a48bec86200010abdef0b5d
--- /dev/null
+++ b/src/main/scala/lib/Employee.scala
@@ -0,0 +1,21 @@
+package lib
+
+class Employee(protected var salary: Double, p_Name: String) extends Person(p_Name) {
+
+  def getSalary(): Double = {
+    salary
+  }
+
+  def setSalary(s: Double): Unit = {
+    salary = s
+  }
+
+  override def toString(): String = {
+    "Employee:" + " salary=" + salary + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/lib/EmployeeManagerEmployee.scala b/src/main/scala/lib/EmployeeManagerEmployee.scala
new file mode 100644
index 0000000000000000000000000000000000000000..d195cf948c79556826e916cab058d448b5b927c1
--- /dev/null
+++ b/src/main/scala/lib/EmployeeManagerEmployee.scala
@@ -0,0 +1,46 @@
+package lib
+
+import org.rosi_project.model_management.sum.compartments.IDirectAssoziation
+
+class EmployeeManagerEmployee(private val sInstance: Employee, private val tInstance: Employee) extends IDirectAssoziation {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[EmployeeManagerEmployee " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Employee = {
+    return sInstance
+  }
+
+  def getTargetIns(): Employee = {
+    return tInstance
+  }
+
+  class Source extends IDirectAssoziationSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectAssoziationTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/lib/HelperPerson.scala b/src/main/scala/lib/HelperPerson.scala
new file mode 100644
index 0000000000000000000000000000000000000000..bd3cd004a776eaf64cfe5390caa6795c488d2ff0
--- /dev/null
+++ b/src/main/scala/lib/HelperPerson.scala
@@ -0,0 +1,19 @@
+package lib
+
+import org.rosi_project.model_management.sum.query.QueryHelper
+
+class HelperPerson(p_Name: String) extends Person(p_Name) with QueryHelper {
+
+  override def equals(that: Any): Boolean = {
+    that.isInstanceOf[Person]
+  }
+
+  override def toString(): String = {
+    "HelperPerson:" + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/lib/Library.scala b/src/main/scala/lib/Library.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2b19d5501cb76fb11cef5569441475e730bcac8c
--- /dev/null
+++ b/src/main/scala/lib/Library.scala
@@ -0,0 +1,21 @@
+package lib
+
+class Library(protected var name: String) {
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  override def toString(): String = {
+    "Library:" + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/lib/LibraryEmployeesEmployee.scala b/src/main/scala/lib/LibraryEmployeesEmployee.scala
new file mode 100644
index 0000000000000000000000000000000000000000..7c6dfd924c934a70d56d346bc8a455f01c6cd61c
--- /dev/null
+++ b/src/main/scala/lib/LibraryEmployeesEmployee.scala
@@ -0,0 +1,46 @@
+package lib
+
+import org.rosi_project.model_management.sum.compartments.IDirectComposition
+
+class LibraryEmployeesEmployee(private val sInstance: Library, private val tInstance: Employee) extends IDirectComposition {
+
+  override def internalInitialize(): Unit = {
+    this.source = new Source()
+    this.target = new Target()
+    sInstance play this.source
+    tInstance play this.target
+  }
+
+  override def toString(): String = {
+    "[LibraryEmployeesEmployee " + source + ", " + target + "]"
+  }
+
+  def getSourceIns(): Library = {
+    return sInstance
+  }
+
+  def getTargetIns(): Employee = {
+    return tInstance
+  }
+
+  class Source extends IDirectCompositionSource {
+
+    override def toString(): String = {
+      "S: (" + sInstance + ")"
+    }
+
+  }
+
+  class Target extends IDirectCompositionTarget {
+
+    override def toString(): String = {
+      "T: (" + tInstance + ")"
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/lib/Person.scala b/src/main/scala/lib/Person.scala
new file mode 100644
index 0000000000000000000000000000000000000000..4ea119087174421e8b1be69327aa261b5c10b52b
--- /dev/null
+++ b/src/main/scala/lib/Person.scala
@@ -0,0 +1,21 @@
+package lib
+
+abstract class Person(protected var name: String) {
+
+  def getName(): String = {
+    name
+  }
+
+  def setName(n: String): Unit = {
+    name = n
+  }
+
+  override def toString(): String = {
+    "Person:" + " name=" + name
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/example/ExampleAml.scala b/src/main/scala/org/rosi_project/example/ExampleAml.scala
new file mode 100644
index 0000000000000000000000000000000000000000..e56258a7ba4c4bc24cd5af367c4071e7f24a88ee
--- /dev/null
+++ b/src/main/scala/org/rosi_project/example/ExampleAml.scala
@@ -0,0 +1,430 @@
+package org.rosi_project.example
+
+import query.AMLLanguageQuery
+import view.AMLLanguageView
+import org.rosi_project.model_management.sum.query._
+import aml._
+import org.rosi_project.model_management.core.ModelElementLists
+
+
+object ExampleAml extends App {
+  
+  val amlView = AMLLanguageView.getNewView()
+  
+  //Prototypes
+  val sucStack = amlView.createSystemUnitClass("Stack", "9")
+  val sucCrane = amlView.createSystemUnitClass("Crane", "10")
+  val sucRamp = amlView.createSystemUnitClass("Rampe", "11")
+  
+  //System model
+  val ihPpu = amlView.createInstanceHierarchy("PPU", "1")
+  val ieStack1 = amlView.createInternalElement("Stack1", "2")
+  val ieCrane2 = amlView.createInternalElement("Crane2", "7")
+  val ieRamp3 = amlView.createInternalElement("Ramp3", "8")
+  val ieConveyor1 = amlView.createInternalElement("Conveyor1", "4")
+  val ieStore1 = amlView.createInternalElement("Store1", "5")
+  val ieSensor1 = amlView.createInternalElement("Sensor1", "6")
+  val attWeigth = amlView.createAttribute("50", "weigth", "3")
+  
+  ihPpu.addInternalElements(ieStack1)
+  ihPpu.addInternalElements(ieCrane2)
+  ihPpu.addInternalElements(ieRamp3)  
+  ieStack1.addInternalElements(ieConveyor1)
+  ieStack1.addInternalElements(ieStore1)
+  ieStack1.addAttributes(attWeigth)  
+  ieStore1.addInternalElements(ieSensor1)
+  
+  //connect prototyp and system model
+  ieStack1.setBaseSystemUnit(sucStack)
+  ieCrane2.setBaseSystemUnit(sucCrane)
+  ieRamp3.setBaseSystemUnit(sucRamp)
+    
+  //ModelElementLists.printAll()
+  
+  //val ieSensor2 = amlView.createInternalElement("Sensor2", "12")
+  //ieStack1.addInternalElements(ieSensor2)
+  
+  //runAllQueries()
+  //runAllViewQueries()
+  query_3()
+  
+  def runAllViewQueries() {
+    //Query testing
+    query_1()
+    query_2()
+    query_3()
+    query_4()
+    query_5()
+    query_6()
+    query_7()
+    query_8()
+  }
+  
+  def runAllQueries() {
+    //Query testing
+    query1()
+    query2()
+    query3()
+    query4()
+    query5()
+    query6()
+    query7()
+    query8()
+  }
+  
+  /**
+   * Search for all objects that inherit from the CAEXObject.
+   */
+  def query1(): Unit = {
+    //Query Objects
+    val q1 = new Query("Q1")
+    val co = new HelperCAEXObject("", "") //laufe über alle naturals im RSUM und suche, die die davon instanzen sind
+    
+    //Query Roles & Settings
+    val r0 = q1.addQueryRole(co)
+    r0.label = "CO"
+    
+    println(q1)
+    println(q1.runQuery())
+  }
+  
+  def query1Dot1(): Unit = {
+    //Query Objects
+    val q11 = new Query("Q1.1")
+    val suc = new SystemUnitClass("SUC", "13")
+    
+    //Query Roles & Settings
+    val r0 = q11.addQueryRole(suc)
+    r0.label = "SUC"    
+    
+    println(q11)
+    println(q11.runQuery())
+  }
+  
+  /**
+   * Search for internal elements with special attribute properties.
+   */
+  def query2(): Unit = {
+    //Query Objects
+    val q2 = new Query("Q2")
+    val ie = new InternalElement("", "")
+    val att = new Attribute("50", "weigth", "")
+    val ieRatt = new SystemUnitClassAttributesAttribute(ie, att)
+    ieRatt.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q2.addQueryRole(ie)
+    r0.label = "IE"
+    val r1 = q2.addQueryRole(att)
+    r1.addAttributeFilter("name", "weigth", CheckingOption.equalsCheck)
+    r1.addAttributeFilter("value", "49", CheckingOption.biggerThan)
+    r1.label = "ATT"
+    val r2 = q2.addQueryRole(ieRatt)
+    
+    println(q2)
+    println(q2.runQuery())
+  }
+  
+  /**
+   * Searches for all childs of the "PPU" element
+   */
+  def query3(): Unit = {
+    //Query Objects
+    val q3 = new Query("Q3")
+    val ih = new InstanceHierarchy("PPU","")
+    val ie = new InternalElement("", "")
+    val ihRie = new InstanceHierarchyInternalElementsInternalElement(ih, ie)
+    ihRie.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q3.addQueryRole(ie)
+    r0.label = "IE"
+    val r1 = q3.addQueryRole(ih)
+    r1.addAttributeFilter("name", "PPU", CheckingOption.equalsCheck)
+    r1.label = "IH"
+    r1.returned = false
+    val r2 = q3.addQueryRole(ihRie)
+    
+    println(q3)
+    println(q3.runQuery())
+  }  
+  
+  /**
+   * Searches all "PPU" elements with 2 deep childs.
+   */
+  def query4(): Unit = {
+    //Query Objects
+    val q4 = new Query("Q4")
+    val ih = new InstanceHierarchy("PPU","") //wie kann ich auf die eigenschaften und werte prüfen
+    val ie1 = new InternalElement("", "")
+    val ie2 = new InternalElement("", "")
+    val ihRie = new InstanceHierarchyInternalElementsInternalElement(ih, ie1)
+    val ieRie = new SystemUnitClassInternalElementsInternalElement(ie1, ie2)
+    ihRie.internalInitialize()
+    ieRie.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q4.addQueryRole(ie1)
+    r0.label = "IE1"
+    val r1 = q4.addQueryRole(ie2)
+    r1.label = "IE2"
+    val r2 = q4.addQueryRole(ih)
+    r2.addAttributeFilter("name", "PPU", CheckingOption.equalsCheck)
+    r2.label = "IH"
+    r2.returned = false
+    val r3 = q4.addQueryRole(ihRie)
+    val r4 = q4.addQueryRole(ieRie)
+    
+    println(q4)
+    println(q4.runQuery())
+  }
+  
+  /**
+   * Searches for all internal elements of the
+   * PPU instance hierarchy. Make transitive closure.
+   */
+  def query5(): Unit = {
+    //Query Objects
+    val q5 = new Query("Q5")
+    val ih = new InstanceHierarchy("PPU","") //wie kann ich auf die eigenschaften und werte prüfen
+    val ie1 = new InternalElement("", "")
+    val ie2 = new InternalElement("", "")
+    val ihRie = new InstanceHierarchyInternalElementsInternalElement(ih, ie1)
+    val ieRie = new SystemUnitClassInternalElementsInternalElement(ie1, ie2)
+    ihRie.internalInitialize()
+    ieRie.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q5.addQueryRole(ie1)
+    r0.label = "IE1"
+    val r1 = q5.addQueryRole(ie2)
+    r1.label = "IE2"
+    r1.transitive = true
+    val r2 = q5.addQueryRole(ih)
+    r2.addAttributeFilter("name", "PPU", CheckingOption.equalsCheck)
+    r2.label = "IH"
+    r2.returned = false
+    val r3 = q5.addQueryRole(ihRie)
+    val r4 = q5.addQueryRole(ieRie)
+    
+    println(q5)
+    println(q5.runQuery())
+  }
+  
+  /**
+   * Get all leave nodes.
+   */
+  def query6(): Unit = {
+    //Query Objects
+    val q6 = new Query("Q6")
+    val ie1 = new InternalElement("", "")
+    val ie2 = new InternalElement("", "")
+    val ieRie = new SystemUnitClassInternalElementsInternalElement(ie1, ie2)
+    ieRie.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q6.addQueryRole(ie1)
+    r0.label = "IE1"
+    val r1 = q6.addQueryRole(ie2)
+    r1.label = "IE2"
+    r1.negated = true
+    val r2 = q6.addQueryRole(ieRie)
+    
+    println(q6)
+    println(q6.runQuery())
+  }
+  
+  /**
+   * Selects all internal elements that refer 
+   * to a system unit class (SUC) named “Stack”.
+   */
+  def query7(): Unit = {
+    //Query Objects
+    val q7 = new Query("Q7")
+    val suc = new SystemUnitClass("Stack", "")
+    val ie = new InternalElement("", "")
+    val ieRsuc = new  InternalElementBaseSystemUnitSystemUnitClass(ie, suc)
+    ieRsuc.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q7.addQueryRole(ie)
+    r0.label = "IE"
+    val r1 = q7.addQueryRole(suc)
+    r1.addAttributeFilter("name", "Stack", CheckingOption.equalsCheck)
+    r1.label = "SUC"
+    r1.returned = false
+    val r2 = q7.addQueryRole(ieRsuc)
+    
+    println(q7)
+    println(q7.runQuery())
+  }
+  
+  /**
+   * Searches for all internal elements, 
+   * which have more than two internal element as direct child
+   */
+  def query8(): Unit = {
+    //Query Objects
+    val q8 = new Query("Q8")
+    val ie1 = new InternalElement("", "")
+    val ie2 = new InternalElement("", "")
+    val ieRie = new SystemUnitClassInternalElementsInternalElement(ie1, ie2)
+    ieRie.internalInitialize()
+    
+    //Query Roles & Settings
+    val r0 = q8.addQueryRole(ie1)
+    r0.label = "IE1"
+    val r1 = q8.addQueryRole(ie2)
+    r1.label = "IE2"
+    r1.multi = 3 //means >= 3
+    val r2 = q8.addQueryRole(ieRie)
+    
+    println(q8)
+    println(q8.runQuery())
+  }
+  
+  def query_1(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val co = q.createCAEXObject()
+    
+    //Settings
+    co.getQueryObject.label = "CO"    
+        
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+  def query_2(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val ie = q.createInternalElement()
+    val att = q.createAttribute()
+    ie.addAttributes(att)
+    
+    //Settings
+    ie.getQueryObject.label = "IE"
+    att.getQueryObject.label = "ATT"
+    att.setValueView("49", CheckingOption.biggerThan)
+    att.setNameView("weigth", CheckingOption.equalsCheck)
+    //att.getQueryObject().addAttributeFilter("name", "weigth", CheckingOption.equalsCheck)
+    //att.getQueryObject().addAttributeFilter("value", "49", CheckingOption.biggerThan)
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+  def query_3(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val ih = q.createInstanceHierarchy()
+    val ie = q.createInternalElement()
+    ih.addInternalElements(ie)
+    
+    //Settings
+    ie.getQueryObject.label = "IE"
+    ih.getQueryObject.label = "IH"
+    ih.setNameView("PPU", CheckingOption.equalsCheck)
+    //ih.getQueryObject().addAttributeFilter("name", "PPU", CheckingOption.equalsCheck)
+    ih.getQueryObject.returned = false
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+    println("+++++++++++ MJ ++++++++++++++++++++++")
+    q.getQuery().generateModelJoinFromQuery()
+  }  
+  
+  def query_4(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val ih = q.createInstanceHierarchy()
+    val ie1 = q.createInternalElement()
+    val ie2 = q.createInternalElement()
+    ih.addInternalElements(ie1)
+    ie1.addInternalElements(ie2)
+    
+    //Settings
+    ie1.getQueryObject.label = "IE1"
+    ie2.getQueryObject.label = "IE2"
+    ih.getQueryObject.label = "IH"
+    ih.setNameView("PPU", CheckingOption.equalsCheck)
+    //ih.getQueryObject().addAttributeFilter("name", "PPU", CheckingOption.equalsCheck)
+    ih.getQueryObject.returned = false
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+  def query_5(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val ih = q.createInstanceHierarchy()
+    val ie1 = q.createInternalElement()
+    val ie2 = q.createInternalElement()
+    ih.addInternalElements(ie1)
+    ie1.addInternalElements(ie2)
+    
+    //Settings
+    ie1.getQueryObject.label = "IE1"
+    ie2.getQueryObject.label = "IE2"
+    ie2.getQueryObject.transitive = true
+    ih.getQueryObject.label = "IH"
+    ih.setNameView("PPU", CheckingOption.equalsCheck)
+    //ih.getQueryObject().addAttributeFilter("name", "PPU", CheckingOption.equalsCheck)
+    ih.getQueryObject.returned = false
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+  def query_6(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val ie1 = q.createInternalElement()
+    val ie2 = q.createInternalElement()
+    ie1.addInternalElements(ie2)
+    
+    //Settings
+    ie1.getQueryObject.label = "IE1"
+    ie2.getQueryObject.label = "IE2"
+    ie2.getQueryObject.negated = true
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+  def query_7(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val suc = q.createSystemUnitClass()
+    val ie = q.createInternalElement()
+    ie.setBaseSystemUnit(suc)
+    
+    //Settings
+    ie.getQueryObject.label = "IE"
+    suc.getQueryObject.label = "SUC"
+    suc.setNameView("Stack", CheckingOption.equalsCheck)
+    //suc.getQueryObject().addAttributeFilter("name", "Stack", CheckingOption.equalsCheck)
+    suc.getQueryObject.returned = false
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+  def query_8(): Unit = {
+    //Query Objects
+    val q = new AMLLanguageQuery
+    val ie1 = q.createInternalElement()
+    val ie2 = q.createInternalElement()
+    ie1.addInternalElements(ie2)
+    
+    //Settings
+    ie1.getQueryObject.label = "IE1"
+    ie2.getQueryObject.label = "IE2"
+    ie2.getQueryObject.multi = 3 //means >= 3
+    
+    println(q.getQuery())
+    println(q.getQuery().runQuery())
+  }
+  
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/example/ExampleRSUM.scala b/src/main/scala/org/rosi_project/example/ExampleRSUM.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c536c519c1c2028358fadf2b1d3155b842ffbd16
--- /dev/null
+++ b/src/main/scala/org/rosi_project/example/ExampleRSUM.scala
@@ -0,0 +1,63 @@
+package org.rosi_project.example
+
+import view.LibraryView
+import view.Manager0
+import view.LibrarySimple0
+
+object ExampleRSUM extends App {
+    
+  println("%%%%%%%%%%%%%%%%%%%%%% Create a view with all data %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  var completeView: LibraryView = LibraryView.getNewView()
+    
+  println("%%%%%%%%%%%%%%%%%%%%%% Create elements in the view %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  var libRole = completeView.createLibrary("City Library")
+  var empRole = completeView.createEmployee(45000, "Bill Smith")
+  var manRole = completeView.createEmployee(60000, "Bob Jones")
+  libRole.addEmployees(empRole)
+  empRole.setManager(manRole)
+  
+  println(libRole.getNameView())
+  
+  completeView.printViewRoles()
+    
+  var list = completeView.getAllViewElements
+    
+  println("Test1 " + completeView.getElementsWithClassName("LibraryRole"))
+  println("Test2 " + completeView.getElementsWithExample(empRole))
+  println("Test3 " + completeView.getMapOfElements())
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Activate other views %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  var managerView: Manager0 = Manager0.getNewView()
+  var simpleView: LibrarySimple0 = LibrarySimple0.getNewView()
+
+  completeView.printViewRoles()
+  managerView.printViewRoles()
+  simpleView.printViewRoles()
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Create a new relation %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  libRole.addEmployees(manRole)
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Change the name of an employee in a view %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  empRole.setNameView("Max Smith")
+
+  completeView.printViewRoles()
+  managerView.printViewRoles()
+  simpleView.printViewRoles()
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Remove an employee %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  //libRole.deleteElement()
+  empRole.deleteElement()
+  //manRole.deleteElement()
+  //hasMan.deleteElement()
+  //hasEmp2.deleteElement()
+
+  completeView.printViewRoles()
+  managerView.printViewRoles()
+  simpleView.printViewRoles()
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/example/ModelJoinExample.scala b/src/main/scala/org/rosi_project/example/ModelJoinExample.scala
new file mode 100644
index 0000000000000000000000000000000000000000..145f2bba9dc68fd00c0b61f506c5b8179829bd21
--- /dev/null
+++ b/src/main/scala/org/rosi_project/example/ModelJoinExample.scala
@@ -0,0 +1,128 @@
+package org.rosi_project.example
+
+import org.rosi_project.model_management.core.RsumCompartment
+import view.EclipseLibraryView
+import view.IMDBdatabaseView
+import java.util.Date
+import view.Simple0
+
+object ModelJoinExample extends App {
+    
+  println("%%%%%%%%%%%%%%%%%%%%%% Create new views %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  var eclipseView = EclipseLibraryView.getNewView()
+  var imdbView = IMDBdatabaseView.getNewView()
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Add joinable filmes %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  var avaFilmRole = imdbView.createFilm(2013, "Avatar Aufbruch nach Pandory")
+  var avaVideoRole = eclipseView.createVideoCassette(false, 230, "Avatar Aufbruch nach Pandory", new Date())
+  var dwFilmRole = imdbView.createFilm(2018, "Death Wish")
+  var asterViedeoRole = eclipseView.createVideoCassette(false, 90, "Asterix erobert Rom", new Date())
+  
+  println(avaVideoRole.getTitleView())
+  
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  RsumCompartment.printStatus
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Add the join view %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  var joinView = Simple0.getNewView()
+    
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Test Println Options for variables %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  joinView.getElementsWithClassName("JoinMovieRole").foreach(r => {
+    val movie = r.asInstanceOf[Simple0#JoinMovieRole]
+    println(movie.getTitleView())
+    println(movie.getMinutesLengthView())
+  })
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Remove Avatar in the Join View %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  joinView.getElementsWithClassName("JoinMovieRole").foreach(r => {
+    val movie = r.asInstanceOf[Simple0#JoinMovieRole]
+    if (movie.getTitleView() == "Avatar Aufbruch nach Pandory") {
+      movie.deleteElement()
+    }
+  })
+  
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Add Death Wish in video view %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  var dwVideoRole = eclipseView.createVideoCassette(true, 98, "Death Wish", new Date())
+  
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus  
+    
+  println("%%%%%%%%%%%%%%%%%%%%%% Create elements in the view %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  var movieRole = joinView.createJoinMovie("Star Trek I", 1979, 132)
+  var filmRole = imdbView.createFilm(1994, "Star Trek VII")
+  
+  println("Year: " + movieRole.getYearView())
+  println("Minutes: " + movieRole.getMinutesLengthView())
+  println("Title: " + movieRole.getTitleView())
+  
+  var list = joinView.getAllViewElements
+        
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Add also video cassette from Star Trek VII %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  var videoRole = eclipseView.createVideoCassette(false, 130, "Star Trek VII", new Date())
+  
+  eclipseView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Add Relations in Film view and show results in other views %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  var imdbRole = imdbView.createIMDB()
+  imdbRole.addFilms(filmRole)
+  
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+  
+  println("%%%%%%%%%%%%%%%%%%%%%% Add Relations in join view and show results in other views %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+  
+  var voteRole = joinView.createVote(6)
+  movieRole.addVotes(voteRole)
+  
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Change the name of Star Trek I in a view %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  movieRole.setTitleView("Star Trek I The Beginning")
+
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+
+  println("%%%%%%%%%%%%%%%%%%%%%% Remove the movie Start Trek I %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")
+
+  movieRole.deleteElement()
+  
+  eclipseView.printViewRoles()
+  imdbView.printViewRoles()
+  joinView.printViewRoles()
+  RsumCompartment.printStatus
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/core/ModelElementLists.scala b/src/main/scala/org/rosi_project/model_management/core/ModelElementLists.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c6b126c863438832e43c28b76893f2cfb880f6c3
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/core/ModelElementLists.scala
@@ -0,0 +1,159 @@
+package org.rosi_project.model_management.core
+
+/**
+ * Provides convenient access to all instances of the synchronized models.
+ *
+ * New models may be registered by name to simplify retrieving their instances.
+ */
+object ModelElementLists {
+
+  var elements: Map[Class[_ <: AnyRef], Set[AnyRef]] = Map()
+  var model2Class: Map[String, Class[_ <: AnyRef]] = Map()
+
+  /**
+   * Inserts a new instance.
+   *
+   * The appropriate model will be inferred automatically
+   *
+   * @param obj the instance. May never be `null`
+   */
+  def addElement(obj: Object): Unit = {
+    if (obj == null) {
+      return
+    }
+
+    var elementsWithClass = elements.get(obj.getClass)
+    
+    if (elementsWithClass.isEmpty) {
+      elements += (obj.getClass -> Set(obj))
+    } else {
+      //var seti = (elementsWithClass.get ++ Set(obj))
+      elements += (obj.getClass -> (elementsWithClass.get + obj))
+    }
+  }
+
+  /**
+   * Queries for all instances of the given class.
+   *
+   * @param clazz the class
+   * @return all matching instances. If none were found or the class is not yet part of the
+   *         repository, an empty list will be returned
+   */
+  def getElementsWithClass(clazz: Class[_ <: AnyRef], excludeSubclasses: Boolean = false): Set[AnyRef] = {
+    var matchingElems: Set[AnyRef] = elements.getOrElse(clazz, Set())
+
+    /*if (!excludeSubclasses) {
+      matchingElems ++= elements
+        .filter(elem => elem._1 != clazz && clazz.isAssignableFrom(elem._1))
+        .values
+        .fold(List[AnyRef]())((l1, l2) => l1 ++ l2)
+    }*/
+
+    matchingElems
+  }
+
+  /**
+   * Queries for all instances of a given model
+   *
+   * @param name the name of the model
+   * @return if the model was found, all its instances will be wrapped in an [[Option]], otherwise
+   *         [[None]] will be returned
+   */
+  def getElementsForModel(name: String): Option[Set[AnyRef]] = {
+
+    if (!model2Class.contains(name)) {
+      None
+    } else {
+      Some(elements.getOrElse(model2Class(name), Set()))
+    }
+
+  }
+
+  def removeElement(obj: AnyRef): Unit = {
+    for { elementsWithClass <- elements.get(obj.getClass) } {
+      val filtered = elementsWithClass.filter(_ != obj)
+
+      elements += (obj.getClass -> filtered)
+    }
+  }
+
+  /**
+   * Informs the repository about what objects belong to which model
+   *
+   * @param name the model's name
+   * @param elemsType the class of the corresponding instances
+   * @throws IllegalArgumentException if the name is already in use
+   */
+  def registerModel(name: String, elemsType: Class[_ <: AnyRef]): Unit = {
+    if (model2Class.contains(name)) {
+      throw new IllegalArgumentException(s"Model is already present: $name")
+    }
+
+    model2Class += (name -> elemsType)
+  }
+
+  def printFromPackage(s: String): Unit = {
+    for (model <- model2Class) {
+      println(s"Model: ${model._1}:")
+
+      elements.getOrElse(model._2, Set()).foreach(e => println(s"++ $e"))
+
+    }
+
+    for { clazz <- elements.keys if !model2Class.exists(t => t._2 == clazz) } {
+      if (clazz.toString().contains(s)) {
+        println(s"Model: $clazz:")
+
+        elements.getOrElse(clazz, Set()).foreach(e => println(s"** $e"))
+      }
+    }
+  }
+  
+  def getElementFromType(s: String): AnyRef = {
+    for { clazz <- elements.keys if !model2Class.exists(t => t._2 == clazz) } {
+      if (clazz.toString().contains(s)) {
+        var es = elements.getOrElse(clazz, Set())
+        if (es.isEmpty) {
+          return null
+        } else {
+          return es.head
+        }
+      }
+    }
+    return null
+  }
+
+  def getElementsFromType(s: String): Set[AnyRef] = {
+    for { clazz <- elements.keys if !model2Class.exists(t => t._2 == clazz) } {
+      if (clazz.toString().contains(s)) {
+        return elements.getOrElse(clazz, Set())
+      }
+    }
+    return Set()
+  }
+  
+  def getDirectElementsFromType(s: String): Set[AnyRef] = {
+    for { clazz <- elements.keys if !model2Class.exists(t => t._2 == clazz) } {
+      if (clazz.getName == s) {
+        return elements.getOrElse(clazz, Set())
+      }
+    }
+    return Set()
+  }
+
+  def printAll(): Unit = {
+    for (model <- model2Class) {
+      println(s"Model: ${model._1}:")
+
+      elements.getOrElse(model._2, Set()).foreach(e => println(s"++ $e"))
+
+    }
+
+    for { clazz <- elements.keys if !model2Class.exists(t => t._2 == clazz) } {
+      println(s"Model: $clazz:")
+
+      elements.getOrElse(clazz, Set()).foreach(e => println(s"** $e"))
+    }
+  }
+
+}
diff --git a/src/main/scala/org/rosi_project/model_management/core/PlayerSync.scala b/src/main/scala/org/rosi_project/model_management/core/PlayerSync.scala
new file mode 100644
index 0000000000000000000000000000000000000000..2f0cbbef6e916ef942ea7cea173d42973f396013
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/core/PlayerSync.scala
@@ -0,0 +1,30 @@
+package org.rosi_project.model_management.core
+
+import scroll.internal.MultiCompartment
+
+trait PlayerSync extends MultiCompartment {
+  
+  buildClass()
+
+  var deleted: Boolean = false
+
+  def isDeleted: Boolean = deleted
+
+  def buildClass(): Unit = {
+    //println("Create New Class")
+    if (!SynchronizationCompartment.isUnderConstruction()) {
+      SynchronizationCompartment combine this
+      val mani = SynchronizationCompartment.createRoleManager()
+      this play mani
+      mani.manage(this)
+      //this play SynchronizationCompartment.createRoleManager()
+      //+this manage this
+    }
+  }
+
+  def deleteObjectFromSynchro(): Unit = {
+    //println("Delete Object")
+    +this deleteManage this
+    deleted = true
+  }
+}
diff --git a/src/main/scala/org/rosi_project/model_management/core/RsumCompartment.scala b/src/main/scala/org/rosi_project/model_management/core/RsumCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..b0835796ce78a1fa3e968481793b6fc52ac93c18
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/core/RsumCompartment.scala
@@ -0,0 +1,273 @@
+package org.rosi_project.model_management.core
+
+import scroll.internal.MultiCompartment
+import scala.collection.mutable.ListBuffer
+import org.rosi_project.model_management.sum._
+import org.rosi_project.model_management.sum.roles._
+import org.rosi_project.model_management.sum.join._
+import org.rosi_project.model_management.sum.compartments.IRelationCompartment
+
+object RsumCompartment extends MultiCompartment {
+
+  //all active extensions
+  private var activeExtensions = ListBuffer[IExtensionCompartment]()
+  //all active views
+  private var activeViews = ListBuffer[IViewCompartment]()
+  
+  //all registered views
+  private var viewInfos = ListBuffer[IViewTypeInfo]()
+  private var joinInfos = ListBuffer[IJoinInfo]()
+
+  //elements in the RSUM
+  private var relations = ListBuffer[IRelationCompartment]()
+  private var naturals = ListBuffer[Object]()
+  private var joins = ListBuffer[IJoinCompartment]()
+  
+  //TODO: look if this method needs different visibility
+  def getNaturals(): ListBuffer[Object] = naturals
+  def getRelations(): ListBuffer[IRelationCompartment] = relations
+  def getJoins(): ListBuffer[IJoinCompartment] = joins  
+  
+  private[model_management] def addJoinCompartment(joinInfo: IJoinInfo): Unit = {
+    if (joinInfo == null || joinInfos.contains(joinInfo)) {
+      return
+    }
+    joinInfos += joinInfo
+    
+    val bases = RsumCompartment.getNaturals().filter(joinInfo.isInstanceBaseModel(_))
+    val others = RsumCompartment.getNaturals().filter(joinInfo.isInstanceOtherModel(_))
+    //b can only match with one o TODO: uses last one if more than one matches
+    //TODO: also iterate over joins to allow deep joins
+    bases.foreach(b => {
+      var other: Object = null
+      others.foreach(o => {
+        if (joinInfo.matchTwoObjects(b, o)) {
+          other = o
+        }
+      })
+      if (other != null || joinInfo.getJoinType() == RsumJoinType.outer) {
+        //join should be added before a view that needs it
+        val j = joinInfo.getNewInstance(b, other)
+        val rsumManager = new RsumManager
+        j play rsumManager
+        rsumManager.manageRsum(j)
+      }      
+    })
+  }
+    
+  def printStatus (): Unit = {
+    println("****************************************")
+    println("Naturals: " + naturals.size + " N: " + naturals)
+    println("Relations: " + relations.size + " R: " + relations)
+    println("Joins: " + joins.size + " J: " + joins)
+    println("****************************************")
+  }
+  
+  def isViewTypeInfo(info: IViewTypeInfo): Boolean = viewInfos.contains(info)
+  
+  def isActiveExtension(extension: IExtensionCompartment): Boolean = activeExtensions.contains(extension)
+  
+  def isActiveView(view: IViewCompartment): Boolean = activeViews.contains(view)
+  
+  def isActiveViewFromName(name: String): Boolean = {
+    activeViews.filter(_.getViewName() == name).foreach(
+        v => return true)
+    return false
+  }
+
+  def getActiveViewFromName(name: String): IViewCompartment = {
+    activeViews.filter(_.getViewName() == name).foreach(
+        v => return v)
+    return null;
+  }
+  
+  def addViewTypeInfo(view: IViewTypeInfo): IViewTypeInfo = {
+    //look if there is a view with this name
+    viewInfos.filter(_.getViewName() == view.getViewName()).foreach(v => {
+      println("View with name " + v.getViewName() + " is already known!")
+      return v
+    })
+    viewInfos = viewInfos :+ view
+    view.getJoinInfos().foreach(this.addJoinCompartment(_))
+    return view
+  }
+  
+  def createActiveViewFromName(name: String): IViewCompartment = {
+    //look if there is a view with this name
+    viewInfos.filter(_.getViewName() == name).foreach(
+        v => return this.createView(v))
+    println("View with name %s is not known!", name)
+    return null
+  }    
+
+  def createActiveView(view: IViewTypeInfo): IViewCompartment = {
+    return this.createView(this.addViewTypeInfo(view))
+  }
+
+  def deleteActiveView(view: IViewCompartment): Boolean = {
+    if (view == null || !activeViews.contains(view))
+      return false    
+    view.deleteAllRoles()
+    activeViews -= view
+    return true
+  }
+  
+  private def createView(view: IViewTypeInfo): IViewCompartment = {
+    return addActiveView(view.getViewRsumInstance())
+  }
+  
+  private[model_management] def addActiveView(view: IViewCompartment): IViewCompartment = {
+    //look if the view is registered
+    if (viewInfos.filter(_.getViewName() == view.getViewName()).isEmpty) {
+      return null
+    }
+    //look if their exists a view with the same name
+    //TODO: should be possible to create 2 views with same name
+    activeViews.filter(_.getViewName() == view.getViewName()).foreach(v => {
+      println("Two views with the same name can not be created, return old view")
+      return v
+    })
+    activeViews = activeViews :+ view
+    //combine the view with the rsum compartment   
+    this combine view
+    //add the view roles
+    naturals.foreach(n => view.getViewRole(n))
+    joins.foreach(j => view.getViewRole(j))
+    relations.foreach(r => view.getViewRole(r))
+    return view
+  }  
+
+  def addExtension(comp: IExtensionCompartment): Boolean = {
+    activeExtensions.foreach { e =>
+      //extension already integrated (ignore)
+      if (e.getExtensionName().equals(comp.getExtensionName())) {
+        println("Their already exists an extension compartment with this name")
+        return false
+      }
+    }
+    activeExtensions = activeExtensions :+ comp
+    //combine the extension with the rsum compartment
+    this combine comp
+    //adds the extension roles
+    relations.foreach(r => comp.getExtensionRole(r))
+    naturals.foreach(n => comp.getExtensionRole(n))
+    joins.foreach(j => comp.getExtensionRole(j))
+    return true
+  }
+
+  def removeExtension(name: String): Boolean = {
+    var extension: IExtensionCompartment = null
+    //find extension by name
+    activeExtensions.filter(_.getExtensionName() == name).foreach(e => extension = e)
+    //remove
+    if (extension != null) {
+      extension.deleteAllRoles()
+      activeExtensions -= extension
+      return true
+    }    
+    println("No extension with such a name!")
+    return false
+  }
+  
+  private def newObject(obj: Object): Unit = {   
+    //TODO: add here implementation for deep joins
+    //TODO: new function to get naturals and joins in one list
+    //obj should not be in the join and must be a type of it
+    joinInfos.filter(_.canMatchWithNewJoin(obj)).foreach(joinInfo => {      
+      var other: Object = null
+      var newJoin: IJoinCompartment = null
+      if (joinInfo.isInstanceBaseModel(obj)) {
+        //can be a new base instance, should not be possible that is is connect with one that is already connected
+        RsumCompartment.getNaturals().filter(n => joinInfo.isInstanceOtherModel(n) && joinInfo.matchTwoObjects(obj, n) && !joinInfo.containsObject(n)).foreach(other = _)
+        if (other != null || joinInfo.getJoinType() == RsumJoinType.outer) {
+          newJoin = joinInfo.getNewInstance(obj, other)
+        }
+      } else {
+        if (joinInfo.getJoinType() == RsumJoinType.outer) {
+          //search alle join instances from this join for a base model without connection that mathes to this obj
+          RsumCompartment.getJoins().filter(j => j.hasEmptyOther() && j.getJoinInfo().isInstanceOtherModel(obj) && j.getJoinInfo().matchTwoObjects(j.baseObj, obj)).foreach(_.addOther(obj))
+        } else {
+          //if its no outer join search for all naturals if one match that is currently not in the join
+          RsumCompartment.getNaturals().filter(n => joinInfo.isInstanceBaseModel(n) && joinInfo.matchTwoObjects(n, obj) && !joinInfo.containsObject(n)).foreach(other = _)
+          if (other != null) {
+            newJoin = joinInfo.getNewInstance(other, obj)
+          }
+        }
+      }
+      if (newJoin != null) {
+        var rsumManager: RsumManager = new RsumManager()
+        newJoin play rsumManager
+        rsumManager.manageRsum(newJoin)
+      }
+    })
+  }
+
+  class RsumManager() extends IRsumRole {
+
+    def manageRsum(incommingPlayer: Object): Unit = {
+      if (incommingPlayer == null)
+        return
+        
+      ModelElementLists.addElement(incommingPlayer)
+
+      incommingPlayer match {
+        case r: IRelationCompartment =>
+          r.initialize()
+          RsumCompartment.this combine r
+          //add to list with relations
+          relations = relations :+ r
+        case j: IJoinCompartment =>
+          //TODO: implement here deep joins
+          //newObject(j)
+          //add to list with joins
+          joins = joins :+ j
+        case n: Object =>
+          newObject(n)
+          //add to list with naturals
+          naturals = naturals :+ n
+      }
+
+      //add all roles from extension compartments
+      activeExtensions.foreach(e => e.getExtensionRole(incommingPlayer))
+      //create new elements in other views
+      activeViews.foreach(v => v.getViewRole(incommingPlayer))      
+    }
+
+    def deleteEverything(): Unit = {
+      val playerObj = this.player.right.get
+      
+      ModelElementLists.removeElement(playerObj)
+      
+      val roles = playerObj.roles()
+      //iterate over all roles and call remove methods
+      //remove methods from the rule also remove the role from the graph      
+      roles.filter(_.isInstanceOf[IRsumRole]).foreach(r => {
+        //println("Delete RsumRole (Extension, View, or Relation) Role: " + r)
+        val rsumRole = r.asInstanceOf[IRsumRole]
+        rsumRole.removeRole()
+      })
+      
+      //remove element from internal element lists
+      if (playerObj.isInstanceOf[IRelationCompartment]) {
+        val relation = playerObj.asInstanceOf[IRelationCompartment]
+        relation.deleteCompartment()
+        relations -= relation
+      } else if (playerObj.isInstanceOf[IJoinCompartment]) {
+        val join = playerObj.asInstanceOf[IJoinCompartment]
+        join.deleteCompartment()
+        joins -= join
+      } else {
+        naturals -= playerObj
+      }
+      //println("All Count: " + plays.allPlayers.size)
+    }
+
+    def changeSomething(): Unit = {
+      +this runExtension ()
+    }
+    
+    private[model_management] def removeRole(): Unit = {
+      this.remove()
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/core/SynchronizationCompartment.scala b/src/main/scala/org/rosi_project/model_management/core/SynchronizationCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..bd5886a849df8b2eb41a3a3e1842b13ac7d024b3
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/core/SynchronizationCompartment.scala
@@ -0,0 +1,462 @@
+package org.rosi_project.model_management.core
+
+import scala.collection.Seq
+import scala.collection.mutable.ListBuffer
+import scala.collection.immutable.Set
+import scala.util.control.Breaks._
+
+import org.rosi_project.model_management.sync._
+import org.rosi_project.model_management.sync.roles._
+import org.rosi_project.model_management.sync.compartments._
+
+object SynchronizationCompartment extends ISynchronizationCompartment {
+
+  def createRoleManager(): IRoleManager = new RoleManager()
+
+  private var activeConstructionCompartment: IConstructionCompartment = null //object
+  private var activeDestructionCompartment: IDestructionCompartment = null //object
+  private var activeSyncCompartmentInstances = Set.empty[ISyncCompartment] //classes
+  private var activeExtensionCompartments = Set.empty[IExtenstionCompartment] //objects
+
+  private var availableExtensionCompartments: List[IExtenstionCompartment] = List[IExtenstionCompartment]()
+  private var availableConstructionCompartments: List[IConstructionCompartment] = List[IConstructionCompartment]()
+  private var availableDestructionCompartments: List[IDestructionCompartment] = List[IDestructionCompartment]()
+  private var availableSyncCompartments: List[ISyncCompartment] = List[ISyncCompartment]()
+
+  changeConstructionRule(SuppressingConstructionCompartment)
+  changeDestructionRule(GeneralDestructor)
+
+  def getConstructionRule(): IConstructionCompartment = activeConstructionCompartment
+
+  def getDestructionRule(): IDestructionCompartment = activeDestructionCompartment
+
+  def getSyncRules(): Set[ISyncCompartment] = activeSyncCompartmentInstances
+
+  def getExtensions(): Set[IExtenstionCompartment] = activeExtensionCompartments
+
+  def getAvailableConstructionRule(): List[IConstructionCompartment] = availableConstructionCompartments
+
+  def getAvailableDestructionRule(): List[IDestructionCompartment] = availableDestructionCompartments
+
+  def getAvailableSyncRules(): List[ISyncCompartment] = availableSyncCompartments
+
+  def getAvailableExtensions(): List[IExtenstionCompartment] = availableExtensionCompartments
+
+  /**
+   * Method for Debug Output.
+   */
+  private def debugCompleteRoleGraphOutput(): Unit = {
+    println("")
+    val nodes = this.allPlayers
+    nodes.foreach { n =>
+      println("Output N: " + n + " Player: " + n.player)
+    }
+    println("")
+  }
+
+  /**
+   * Method for Debug Output.
+   */
+  private def debugSyncRoleGraphOutput(): Unit = {
+    println("")
+    val nodes = this.allPlayers
+    nodes.foreach {
+      case n: ISyncRole =>
+        val role: ISyncRole = n.asInstanceOf[ISyncRole]
+        val compart: ISyncCompartment = role.getOuterCompartment
+        println("Output N: " + n + " Player: " + n.player + " Comp: " + compart + " RN: " + compart.getRuleName)
+      case _ =>
+    }
+    println("")
+  }
+
+  /**
+   * Method for Debug Output.
+   */
+  private def debugPlayerRolesOutput(): Unit = {
+    println("")
+    val nodes = this.allPlayers
+    nodes.foreach {
+      case player: PlayerSync =>
+        println("Output N: " + player.roles())
+      case _ =>
+    }
+    println("")
+  }
+
+  def registerConstructionCompartment(compartment: IConstructionCompartment): Unit = {
+    if (compartment == null)
+      return
+    if (!availableConstructionCompartments.contains(compartment)) {
+      availableConstructionCompartments = availableConstructionCompartments :+ compartment
+      this combine compartment
+    }
+  }
+
+  def registerDestructionCompartment(compartment: IDestructionCompartment): Unit = {
+    if (compartment == null)
+      return
+    if (!availableDestructionCompartments.contains(compartment)) {
+      availableDestructionCompartments = availableDestructionCompartments :+ compartment
+      this combine compartment
+    }
+  }
+
+  def registerSyncRule(compartment: ISyncCompartment): Unit = {
+    if (compartment == null)
+      return
+    if (!availableSyncCompartments.contains(compartment)) {
+      availableSyncCompartments = availableSyncCompartments :+ compartment
+    }
+  }
+
+  def registerExtensionCompartment(compartment: IExtenstionCompartment): Unit = {
+    if (compartment == null)
+      return
+    if (!availableExtensionCompartments.contains(compartment)) {
+      availableExtensionCompartments = availableExtensionCompartments :+ compartment
+      this combine compartment
+    }
+  }
+
+  def activateExtensionCompartment(compartment: IExtenstionCompartment): Unit = {
+    if (compartment == null)
+      return
+    activeExtensionCompartments += compartment
+    registerExtensionCompartment(compartment)
+  }
+
+  def deactivateExtensionCompartment(compartment: IExtenstionCompartment): Unit = {
+    if (compartment == null)
+      return
+    activeExtensionCompartments -= compartment
+  }
+
+  /**
+   * Change the actual construction role.
+   */
+  def changeConstructionRule(construct: IConstructionCompartment): Unit = {
+    if (construct == null) {
+      return
+    }
+    activeConstructionCompartment = construct
+    registerConstructionCompartment(construct)
+  }
+
+  /**
+   * Change the destruction role.
+   * Set the new one and remove old roles and add new ones.
+   */
+  def changeDestructionRule(destruct: IDestructionCompartment): Unit = {
+    if (destruct == null) {
+      return
+    }
+    if (activeDestructionCompartment == null) {
+      activeDestructionCompartment = destruct
+      registerDestructionCompartment(destruct)
+      return
+    }
+    //debugCompleteRoleGraphOutput()
+    var nodes = this.allPlayers; //get all nodes
+    //delete all destruction roles
+    nodes.foreach { n =>
+      if (n.isInstanceOf[IDestructor])
+        n.remove()
+    }
+    //debugCompleteRoleGraphOutput()
+    //add all new ones
+    nodes = this.allPlayers
+    nodes.foreach {
+      case n: IRoleManager =>
+        //add new role here
+        val player = n.player
+        if (player.isRight) {
+          val realPlayer = player.right.get
+          val newRole = destruct.getDestructorForClassName(realPlayer)
+          n play newRole
+        }
+      case _ =>
+    }
+    //debugCompleteRoleGraphOutput()
+    activeDestructionCompartment = destruct
+
+    registerDestructionCompartment(destruct)
+  }
+
+  /**
+   * Integration of a new Model with an integration compartment.
+   */
+  def integrateNewModel(integrationRule: IIntegrationCompartment): Unit = {
+    this combine integrationRule
+    val nodes = this.allPlayers
+    nodes.foreach {
+      case player: PlayerSync =>
+        val role = integrationRule.getIntegratorForClassName(player)
+        //println("RM: " + n + " Role: " + role)
+        if (role != null) {
+          player play role
+          underConstruction = true;
+          (+player).integrate(player)
+          underConstruction = false;
+          role.remove()
+        }
+      case _ =>
+    }
+    nodes.foreach {
+      case player: PlayerSync =>
+        val role = integrationRule.getRelationalIntegratorsForClassName(player)
+        //println("RM: " + n + " Role: " + role)
+        if (role != null) {
+          player play role
+          underConstruction = true;
+          (+player).integrate(player)
+          underConstruction = false;
+          role.remove()
+        }
+      case _ =>
+    }
+    integrationRule.finalEditFunction()
+  }
+
+  /**
+   * Add a new synchronization rule to the synchronization process.
+   */
+  def addSynchronizationRule(newRule: ISyncCompartment): Unit = {
+    if (newRule == null) {
+      return
+    }
+    //if the rule is in the list stop
+    activeSyncCompartmentInstances.foreach { s =>
+      if (s.getRuleName == newRule.getRuleName)
+        return
+    }
+    activeSyncCompartmentInstances += newRule
+
+    var running = true
+    var nodes = Seq[AnyRef]()
+    //debugSyncRoleGraphOutput()
+    while (running) {
+      breakable {
+        running = false
+        nodes = this.allPlayers; //get all nodes
+        nodes.foreach {
+          case n: RoleManager =>
+            //proof if the role manager does not play this rule
+            var proof = true
+            val player = n.player
+            if (player.isRight) {
+              val realPlayer = player.right.get
+              val relatedRoles = n.roles()
+              //println(realPlayer + "-----" + relatedRoles)
+              relatedRoles.foreach {
+                case syncRole: ISyncRole =>
+                  val syncComp: ISyncCompartment = syncRole.getOuterCompartment
+                  if (syncComp.getRuleName == newRule.getRuleName || !newRule.isFirstIntegration(realPlayer))
+                    proof = false
+                case _ =>
+              }
+
+              //if synchronization compartment was not integrated before then integrate now
+              if (proof) {
+                //add new role to the player
+                //the new compartment
+                val newComp: ISyncCompartment = newRule.getNewInstance
+                val newRole = newComp.getNextIntegrationRole(realPlayer)
+                //println("**" + newComp + " " + newRole + " " + n + " " + realPlayer)
+                if (newRole != null)
+                  n play newRole
+                else
+                  proof = false
+
+                if (proof) {
+                  //add roles to related role manager because on is added to this one
+                  val related = n.getRelatedManager
+                  related.foreach { r =>
+                    val player = r.player
+                    if (player.isRight) {
+                      val realPlayer = player.right.get
+                      if (newComp.isNextIntegration(realPlayer)) {
+                        val newRole = newComp.getNextIntegrationRole(realPlayer)
+                        r play newRole
+                      }
+                    }
+                  }
+                  this combine newComp
+                  running = true
+                  break
+                }
+              }
+            }
+          case _ =>
+
+        }
+      }
+    }
+
+    registerSyncRule(newRule)
+    //debugPlayerRolesOutput()
+    //debugSyncRoleGraphOutput()
+  }
+
+  def hasSynchronizationRule(ruleName: String): Boolean = {
+    activeSyncCompartmentInstances.map(_.getRuleName).contains(ruleName)
+  }
+
+  /**
+   * Delete all rules with this name.
+   */
+  def deleteRule(ruleName: String): Unit = {
+    val nodes = this.allPlayers //get all nodes
+    nodes.foreach {
+      case n: ISyncRole =>
+        val role: ISyncRole = n.asInstanceOf[ISyncRole]
+        val compart: ISyncCompartment = role.getOuterCompartment
+        //println("Destruct1: " + n.isInstanceOf[ISyncRole] + " N: " + n + " Player: " + n.player + " Comp: " + compart + " RN: " + compart.getRuleName() + " From: " + from)
+        if (compart.getRuleName == ruleName) {
+          compart.clearSyncer()
+          n.remove()
+        }
+      case _ =>
+
+    }
+
+    // rule names should be unique (in theory)
+    // but we're better save than sorry
+    val ruleCompartments = activeSyncCompartmentInstances.filter(_.getRuleName == ruleName)
+    for (comp <- ruleCompartments) {
+      activeSyncCompartmentInstances -= comp
+    }
+
+    //debugCompleteRoleGraphOutput()
+  }
+
+  /**
+   * Change rule with this name to new rule.
+   */
+  def changeRuleFromTo(from: String, to: ISyncCompartment): Unit = {
+    var running = true
+    var nodes = Seq[AnyRef]()
+    while (running) {
+      breakable {
+        running = false
+        nodes = this.allPlayers //get all nodes
+        nodes.foreach {
+          case role: ISyncRole =>
+            val compart: ISyncCompartment = role.getOuterCompartment
+            //println("Destruct1: " + n.isInstanceOf[ISyncRole] + " N: " + n + " Player: " + n.player + " Comp: " + compart + " RN: " + compart.getRuleName() + " From: " + from)
+            if (compart.getRuleName == from) {
+              //exchange this with a new compartment
+              val newComp: ISyncCompartment = to.getNewInstance
+              compart.getSyncer.foreach { r =>
+                val manager = (+r).getManager()
+                if (manager.isRight) {
+                  val realManager: RoleManager = manager.right.get(0).right.get
+                  val player = r.player
+                  if (player.isRight) {
+                    val realPlayer = player.right.get
+                    val newRole = newComp.getNextIntegrationRole(realPlayer)
+                    r.remove()
+                    realManager play newRole
+                  }
+                }
+              }
+              //role graph combination
+              this combine newComp
+              //delete compartment
+              compart.clearSyncer()
+              running = true
+              break
+            }
+          case _ =>
+
+        }
+      }
+    }
+
+    // rule names should be unique (in theory)
+    // but we're better save than sorry
+    val oldRuleCompartments = activeSyncCompartmentInstances.filter(_.getRuleName == from)
+    for (comp <- oldRuleCompartments) {
+      activeSyncCompartmentInstances -= comp
+    }
+    activeSyncCompartmentInstances += to
+
+    registerSyncRule(to)
+    //debugSyncRoleGraphOutput()
+  }
+
+  class RoleManager() extends IRoleManager {
+
+    def getRelatedClassFromName(name: String): PlayerSync = {
+      getRelatedManager.foreach(rm => {
+        val realPlayer = rm.player.right.get
+        //TODO: look on more superclasses
+        //println(realPlayer.getClass.getSimpleName + " " + realPlayer.getClass.getName + " " + realPlayer.getClass.getCanonicalName)
+        if (realPlayer.getClass.getName.contains(name) || realPlayer.getClass.getSuperclass.getName.contains(name)) {
+          return realPlayer.asInstanceOf[PlayerSync]
+        }
+      })
+      null
+    }
+
+    def getSetRelatedClassesFromName(name: String): Set[PlayerSync] = {
+      var resultSet: Set[PlayerSync] = Set.empty
+      getRelatedManager.foreach(rm => {
+        val realPlayer = rm.player.right.get
+        if (realPlayer.getClass.getName.contains(name) || realPlayer.getClass.getSuperclass.getName.contains(name)) {
+          resultSet += realPlayer.asInstanceOf[PlayerSync]
+        }
+      })
+      resultSet
+    }
+
+    def insertNotification(): Unit = {
+      //println("Insert Notification")
+      +this notifyInsertion ()
+    }
+
+    def deletionNotification(): Unit = {
+      //println("Deletion Notification")
+      +this notifyDeletion ()
+    }
+
+    def updateNotification(): Unit = {
+      //println("Update Notification")
+      +this notifyUpdate ()
+    }
+
+    def printAllManager(): Unit = {
+      println("++ Ma => Pl: " + this + " | " + this.player.right.get)
+      getRelatedManager().foreach(m => {
+        println("-- Ma => Pl: " + m + " | " + m.player.right.get)
+      })
+    }
+
+    def deleteManage(value: PlayerSync): Unit = {
+      val delete = activeDestructionCompartment.getDestructorForClassName(value)
+      if (delete != null) {
+        this play delete
+        +this deleteRoleFunction ()
+      }
+    }
+
+    def manage(value: PlayerSync): Unit = {
+      val construct = activeConstructionCompartment.getConstructorForClassName(value)
+      if (construct != null) {
+        this play construct
+        underConstruction = true;
+        val _ = +this construct (value, this)
+        underConstruction = false;
+        construct.remove()
+      }
+    }
+
+    /**
+     * Create a relation between two IRoleManager and RoleManager of other PlayerSync instances.
+     */
+    def makePlayerSyncRelated(playerSync: PlayerSync): Unit = {
+      +playerSync makeRelated (this)
+    }
+  }
+
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sum/IExtensionCompartment.scala b/src/main/scala/org/rosi_project/model_management/sum/IExtensionCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..99197114e85985096c8f054bad5b0703cd56ecb0
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/IExtensionCompartment.scala
@@ -0,0 +1,67 @@
+package org.rosi_project.model_management.sum
+
+import scroll.internal.Compartment
+import scala.collection.mutable.ListBuffer
+import org.rosi_project.model_management.sum.roles.IExtensionRole
+import org.rosi_project.model_management.core.RsumCompartment
+
+trait IExtensionCompartment extends Compartment {
+  
+  protected var roles = ListBuffer[IExtensionRole]()
+  
+  protected def getRole(classname: Object) : IExtensionRole
+  
+  private def getRoleFromList(classname: Object): IExtensionRole = {
+    roles.foreach { r =>
+      if (+r == +classname) {
+        return r
+      }
+    }
+    return null
+  }
+  
+  protected def removeRoleFromList(role: IExtensionRole): Unit = {
+    if (roles.contains(role))
+      roles -= role
+  }
+  
+  /**
+   * Get a new extension role for the object. Adds automatically the play relation.
+   */
+  private[model_management] def getExtensionRole(classname: Object) : IExtensionRole = {
+    if (!RsumCompartment.isActiveExtension(this)) {
+      return null
+    }
+    
+    //look if a role from this elements exists in this extension
+    var role: IExtensionRole = getRoleFromList(classname)
+    //YES Return this role
+    if (role != null) {
+      return role
+    }
+    
+    role = this.getRole(classname)
+    if (role != null) {
+      classname play role
+      roles = roles :+ role
+    }
+    return role
+  }
+  
+  //TODO: do we need this function
+  def getNewInstance() : IExtensionCompartment
+  
+  def getExtensionName() : String
+  
+  def deleteAllRoles() : Unit = {
+    roles.foreach(_.remove())
+  }
+  
+  abstract class AExtensionRole extends IExtensionRole {
+    
+    private[model_management] def removeRole(): Unit = {
+      this.remove()
+      IExtensionCompartment.this.removeRoleFromList(this)
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/IViewCompartment.scala b/src/main/scala/org/rosi_project/model_management/sum/IViewCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..84c3746c1cefa1ba6cf7468338ecca4f5f26a21e
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/IViewCompartment.scala
@@ -0,0 +1,237 @@
+package org.rosi_project.model_management.sum
+
+import scroll.internal.Compartment
+import scala.collection.mutable.ListBuffer
+import scala.collection.mutable.Set
+import org.rosi_project.model_management.core.RsumCompartment
+import org.rosi_project.model_management.core.RsumCompartment.RsumManager
+import org.rosi_project.model_management.sum.compartments.IRelationCompartment
+import org.rosi_project.model_management.sum.roles.IViewRole
+import org.rosi_project.model_management.sum.join.IJoinCompartment
+
+trait IViewCompartment extends Compartment {
+
+  private var initRelationRole: Boolean = false
+  private var naturalRoles = ListBuffer[AViewRole]()
+  private var relationalRoles = ListBuffer[AViewRole]()
+
+  /**
+   * Get a map with the simple names of all elements
+   * and the connected elements in the view.
+   */
+  def getMapOfElements(): Map[String, Set[AViewRole]] = {
+    var result: Map[String, Set[AViewRole]] = Map.empty
+    naturalRoles.foreach(n => {
+      if (result.contains(n.getClass.getSimpleName)) {
+        result(n.getClass.getSimpleName) += n
+      } else {
+        result = result + (n.getClass.getSimpleName -> Set(n))
+      }
+    })
+    result
+  }
+
+  /**
+   * Get all elements with the specific simple name.
+   */
+  def getElementsWithClassName(s: String): Set[AViewRole] = {
+    var result: Set[AViewRole] = Set.empty
+    naturalRoles.foreach(n => {
+      if (n.getClass.getSimpleName == s) {
+        result += n
+      }
+    })
+    result
+  }
+
+  /**
+   * Get all elements with the same type from the view.
+   */
+  def getElementsWithExample[A <: IViewRole](a: A): Set[A] = {
+    var result: Set[A] = Set.empty
+    naturalRoles.foreach(n => {
+      if (n.getClass.getName == a.getClass.getName) {
+        result += n.asInstanceOf[A]
+      }
+    })
+    result
+  }
+
+  /**
+   * Get a new view role for the object. Adds automatically the play relation.
+   */
+  private[model_management] def getViewRole(classname: Object): IViewRole = {
+    if (!RsumCompartment.isActiveView(this)) {
+      return null
+    }
+
+    if (!isViewable(classname)) {
+      return null
+    }
+
+    //look if a role from this elements exists in this view
+    var role: AViewRole = getRoleFromList(classname)
+    //YES Return this role
+    if (role != null) {
+      return role
+    }
+
+    //it can not be possible that relations are created without their connection parts before
+    //decide if source or target need a join role than we must look if they are also connected with such a role
+    //NO create a new one
+    if (classname.isInstanceOf[IRelationCompartment]) {
+      //1. Handle the Relational Compartment
+      var comp: IRelationCompartment = classname.asInstanceOf[IRelationCompartment]
+      var source = comp.getSource()
+      var target = comp.getTarget()
+      var sourcePlayer = source.player.right.get
+      var targetPlayer = target.player.right.get
+      var sourceRole: AViewRole = getRoleFromList(source) //should work now with join objects
+      var targetRole: AViewRole = getRoleFromList(target) //should work now with join objects 
+      //requirement that a relational compartment cannot play a role in a relational compartment
+      //if one source does not exists then do not create the new relation
+      if (sourceRole != null && targetRole != null) {
+        initRelationRole = true
+        role = getRelationalRole(classname, sourceRole, targetRole)
+        classname play role
+        initRelationRole = false
+      }      
+    } else {
+      //2. Handle the natural and join types
+      initRelationRole = true
+      role = getNaturalRole(classname)
+      classname play role
+      initRelationRole = false
+    }
+    return role
+  }
+
+  protected def isViewable(classname: Object): Boolean
+  protected def getNaturalRole(classname: Object): AViewRole
+  protected def getRelationalRole(classname: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole
+
+  protected def getRoleFromList(classname: Object): AViewRole = {
+    relationalRoles.foreach(r => {
+      if (+r == +classname) {
+        return r
+      }
+    })
+    naturalRoles.foreach(r => {
+      if (r.player.right.get.isInstanceOf[IJoinCompartment] && !classname.isInstanceOf[IJoinCompartment]) {
+        if (+r joinEquals(classname)) {
+          return r
+        }
+      } else {
+        if (+r == +classname) {
+          return r
+        }
+      }
+    })
+    return null
+  }
+
+  def printViewRoles(): Unit = {
+    println("-------------------------------------------------------------------")
+    println("View: " + this.getViewName() + " #Roles: " + naturalRoles.size)
+    naturalRoles.foreach { r =>
+      var player = r.player.right.get
+      var playerRoles = player.roles()
+      println("* Player: " + player + " - Role: " + r + " - Size: " + playerRoles.size)
+    }
+    relationalRoles.foreach { r =>
+      var player = r.player.right.get
+      var playerRoles = player.roles()
+      println("# Player: " + player + " - Role: " + r + " - Size: " + playerRoles.size)
+    }
+    println("-------------------------------------------------------------------")
+  }
+
+  def getAllViewElements(): ListBuffer[AViewRole] = naturalRoles
+
+  def containsRole(role: AViewRole): Boolean = naturalRoles.contains(role)
+
+  def getViewName(): String
+
+  private[model_management] def deleteAllRoles(): Unit = {
+    naturalRoles.foreach { r =>
+      r.remove()
+    }
+    relationalRoles.foreach { r =>
+      r.remove()
+    }
+  }
+
+  protected def removeRoleFromList(role: AViewRole): Unit = {
+    if (naturalRoles.contains(role))
+      naturalRoles -= role
+    if (relationalRoles.contains(role))
+      relationalRoles -= role
+  }
+
+  private def initElement(element: Object, relational: Boolean, role: AViewRole): Unit = {
+    //proof if the actual view is in
+    if (!RsumCompartment.isActiveView(this)) {
+      return
+    }
+    if (relational)
+      relationalRoles = relationalRoles :+ role
+    else
+      naturalRoles = naturalRoles :+ role
+
+    //do this only if element is created in the view and not somewhere else  
+    if (!initRelationRole) {
+      var rsumManager: RsumManager = new RsumManager()
+      element play rsumManager
+      element play role
+      rsumManager.manageRsum(element)
+    }
+  }
+
+  private def isActive(): Boolean = RsumCompartment.isActiveView(this)
+
+  abstract class AViewRole extends IViewRole {
+
+    initializeElement()
+
+    protected def isRelational(): Boolean
+
+    protected def getCreationObject(): Object
+
+    private def initializeElement(): Unit = {
+      if (isActive) {
+        if (isRelational) {
+          relationalRoles = relationalRoles :+ this
+        } else {
+          naturalRoles = naturalRoles :+ this
+        }
+        if (!initRelationRole) {
+          var rsumManager: RsumManager = new RsumManager()
+          var obj = getCreationObject
+          obj play rsumManager
+          obj play this
+          rsumManager.manageRsum(obj)
+        }
+      }
+    }
+    
+    protected def getPlayerOfType(obj: Object, t: String): Object = {
+      val source: Object = obj.player.right.get
+      if (source.isInstanceOf[IJoinCompartment]) {
+        val joinNats = source.asInstanceOf[IJoinCompartment].getAllJoinNaturals()
+        joinNats.filter(_.getClass.getSimpleName == t).foreach(n => return n)
+      } else {
+        return source
+      }
+      source
+    }
+
+    protected def deleteElement(): Unit = {
+      +this deleteEverything ()
+    }
+
+    private[model_management] def removeRole(): Unit = {
+      this.remove()
+      IViewCompartment.this.removeRoleFromList(this)
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/IViewTypeInfo.scala b/src/main/scala/org/rosi_project/model_management/sum/IViewTypeInfo.scala
new file mode 100644
index 0000000000000000000000000000000000000000..0539b46c189c20bbd4f9c112c3a37c989b87f2d3
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/IViewTypeInfo.scala
@@ -0,0 +1,26 @@
+package org.rosi_project.model_management.sum
+
+import org.rosi_project.model_management.sum.join.IJoinInfo
+import org.rosi_project.model_management.core.RsumCompartment
+
+trait IViewTypeInfo {
+  
+  def getViewName(): String
+  
+  protected def getNewViewTypeInstance(): IViewCompartment = {
+    RsumCompartment.addViewTypeInfo(this)
+    var view = RsumCompartment.getActiveViewFromName(this.getViewName())
+    if (view == null) {
+      return RsumCompartment.addActiveView(this.getNewInstance())
+    }
+    else {
+      return view
+    }
+  }
+  
+  def getJoinInfos(): Set[IJoinInfo]
+  
+  private[model_management] def getViewRsumInstance(): IViewCompartment = getNewInstance
+  
+  protected def getNewInstance(): IViewCompartment
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IAggregation.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IAggregation.scala
new file mode 100644
index 0000000000000000000000000000000000000000..c5e8b397efdaf681b676f35b187e96fa31dd67f2
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IAggregation.scala
@@ -0,0 +1,11 @@
+package org.rosi_project.model_management.sum.compartments
+
+trait IAggregation extends IDirectAggregation {
+  
+  trait IAggregationSource extends IDirectAggregationSource {
+  }
+  
+  trait IAggregationTarget extends IDirectAggregationTarget {
+    def getSource (): ISource = IAggregation.this.source
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IAssociation.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IAssociation.scala
new file mode 100644
index 0000000000000000000000000000000000000000..3296872948a9ef89acb8c8cca7799f0f9127ea92
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IAssociation.scala
@@ -0,0 +1,11 @@
+package org.rosi_project.model_management.sum.compartments
+
+trait IAssociation extends IDirectAssoziation {
+  
+  trait IAssociationSource extends IDirectAssoziationSource {
+  }
+  
+  trait IAssociationTarget extends IDirectAssoziationTarget {    
+    def getSource (): ISource = IAssociation.this.source
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IComposition.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IComposition.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a85581c7659c4791ab3d52d9540060f3b7372834
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IComposition.scala
@@ -0,0 +1,11 @@
+package org.rosi_project.model_management.sum.compartments
+
+trait IComposition extends IDirectComposition {
+  
+  trait ICompositionSource extends IDirectCompositionSource {    
+  }
+  
+  trait ICompositionTarget extends IDirectCompositionTarget {    
+    def getSource (): ISource = IComposition.this.source
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectAggregation.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectAggregation.scala
new file mode 100644
index 0000000000000000000000000000000000000000..6a8e26481c5ae9c82e50e326730622b09083968e
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectAggregation.scala
@@ -0,0 +1,10 @@
+package org.rosi_project.model_management.sum.compartments
+
+trait IDirectAggregation extends IRelationCompartment {
+  
+  trait IDirectAggregationSource extends ISource {
+  }
+  
+  trait IDirectAggregationTarget extends ITarget {
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectAssoziation.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectAssoziation.scala
new file mode 100644
index 0000000000000000000000000000000000000000..ee8e2e89b86ae79712a572b4091bfc2570918809
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectAssoziation.scala
@@ -0,0 +1,10 @@
+package org.rosi_project.model_management.sum.compartments
+
+trait IDirectAssoziation extends IRelationCompartment {
+  
+  trait IDirectAssoziationSource extends ISource {
+  }
+  
+  trait IDirectAssoziationTarget extends ITarget {
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectComposition.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectComposition.scala
new file mode 100644
index 0000000000000000000000000000000000000000..40845447c86ee10bcf457eded226d248277c5cad
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IDirectComposition.scala
@@ -0,0 +1,32 @@
+package org.rosi_project.model_management.sum.compartments
+
+trait IDirectComposition extends IRelationCompartment {
+  
+  override def deleteCompartment () : Unit = {
+    //println("DeleteCompartment IDirectComposition")
+    if (source != null)
+    {
+      source.remove()
+      source = null;
+    }
+    if (target != null)
+    {
+      var player = target.player
+      if (player.isRight) {
+        var realPlayer = player.right.get
+        target.remove()
+        target = null;
+        +realPlayer deleteEverything()
+      }      
+    }
+    //+this deleteEverything()
+  }
+  
+  trait IDirectCompositionSource extends ISource {
+    override private[model_management] def removeRole(): Unit = +IDirectComposition.this deleteEverything()
+  }
+  
+  trait IDirectCompositionTarget extends ITarget {
+    override private[model_management] def removeRole(): Unit = +IDirectComposition.this deleteEverything()
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/compartments/IRelationCompartment.scala b/src/main/scala/org/rosi_project/model_management/sum/compartments/IRelationCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..4af7d9cf596504156178eeac736c6f807fedfee2
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/compartments/IRelationCompartment.scala
@@ -0,0 +1,49 @@
+package org.rosi_project.model_management.sum.compartments
+
+import scroll.internal.Compartment
+import org.rosi_project.model_management.sum.roles.IRelationRole
+import org.rosi_project.model_management.core.PlayerSync
+
+trait IRelationCompartment extends PlayerSync {
+  
+  protected var source: ISource = null;
+  protected var target: ITarget = null;
+  
+  //TODO: change again to protected
+  def internalInitialize(): Unit
+  
+  def getTarget(): ITarget = target
+  
+  def getSource(): ISource = source
+  
+  def initialize(): Unit = {
+    if (source == null && target == null)
+      internalInitialize()
+  }
+  
+  def deleteCompartment () : Unit = {  
+    //println("DeletCompartment IRelationCompartment")
+    if (source != null)
+    {
+      source.remove()
+      source = null;
+    }
+    if (target != null)
+    {
+      target.remove()
+      target = null;
+    }
+    //+this deleteEverything()
+  }
+  
+  trait ISource extends IRelationRole {    
+    def getTarget (): ITarget = IRelationCompartment.this.target
+    private[model_management] def removeRole(): Unit = +IRelationCompartment.this deleteEverything()
+    override def getOuterCompartment(): IRelationCompartment = IRelationCompartment.this
+  }
+  
+  trait ITarget extends IRelationRole {    
+    private[model_management] def removeRole(): Unit = +IRelationCompartment.this deleteEverything()
+    override def getOuterCompartment(): IRelationCompartment = IRelationCompartment.this
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/join/IJoinCompartment.scala b/src/main/scala/org/rosi_project/model_management/sum/join/IJoinCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..5c256dde8dc3be3990deed24fe26c3e1ce0a5f31
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/join/IJoinCompartment.scala
@@ -0,0 +1,123 @@
+package org.rosi_project.model_management.sum.join
+
+import scroll.internal.Compartment
+import org.rosi_project.model_management.sum.roles.IRsumRole
+import org.rosi_project.model_management.core.RsumCompartment.RsumManager
+import org.rosi_project.model_management.core.RsumCompartment
+
+trait IJoinCompartment extends Compartment {
+  var baseObj: Object = null
+  var otherObj: Object = null
+    
+  protected val baseRole: BaseRole = new BaseRole
+  protected val otherRole: OtherRole = new OtherRole
+  
+  def getJoinInfo(): IJoinInfo
+  
+  def getAllJoinNaturals(): Set[Object] = {
+    var bases: Set[Object] = Set(baseObj)
+    if (baseObj.isInstanceOf[IJoinCompartment]) {
+      bases = baseObj.asInstanceOf[IJoinCompartment].getAllJoinNaturals()
+    }
+    if (otherObj != null) {
+      var others: Set[Object] = Set(otherObj)
+      if (otherObj.isInstanceOf[IJoinCompartment]) {
+        others = otherObj.asInstanceOf[IJoinCompartment].getAllJoinNaturals()
+      }
+      return others ++ bases
+    }
+    return bases
+  }
+  
+  def hasEmptyOther(): Boolean = otherObj == null
+  
+  def joinEquals(obj: Object): Boolean = {
+    var baseEquals: Boolean = false
+    var otherEquals: Boolean = false
+    if (baseObj.isInstanceOf[IJoinCompartment]) {
+      baseEquals = baseObj.asInstanceOf[IJoinCompartment].joinEquals(obj)
+    } else {
+      baseEquals = +obj == +baseObj
+    }
+    if (otherObj.isInstanceOf[IJoinCompartment]) {
+      otherEquals = otherObj.asInstanceOf[IJoinCompartment].joinEquals(obj)
+    } else {
+      otherEquals = +obj == +otherObj
+    }
+    baseEquals || otherEquals
+  }
+  
+  def addOther(obj: Object): Unit = {
+    if (obj != null && otherObj == null) {
+      getJoinInfo.addObject(obj)
+      otherObj = obj
+      otherObj play otherRole
+    }
+  }
+  
+  //if deletion comes from down than is stop in roles
+  def deleteCompartment(): Unit = {
+    if (baseObj != null) {
+      getJoinInfo.removeObject(baseObj)
+      baseRole.remove()
+      +baseObj deleteEverything()
+    }
+    if (otherObj != null) {
+      getJoinInfo.removeObject(otherObj)
+      otherRole.remove()
+      +otherObj deleteEverything()
+    }
+  }
+  
+  private[join] def objectInitialization(base: Object, other: Object): Unit = {
+    if (base != null) {
+      getJoinInfo.addObject(base)
+      baseObj = base
+      base play baseRole
+    }
+    if (other != null) {
+      getJoinInfo.addObject(other)
+      otherObj = other
+      other play otherRole      
+    }
+  }
+  
+  protected def initialize(base: Object, other: Object): Unit = {
+    RsumCompartment.combine(this)
+    var rsumManager: RsumManager = null
+    if (base != null) {
+      getJoinInfo.addObject(base)
+      baseObj = base
+      base play baseRole
+      rsumManager = new RsumManager()
+      base play rsumManager
+      rsumManager.manageRsum(base)
+    }
+    if (other != null) {
+      getJoinInfo.addObject(other)
+      otherObj = other
+      other play otherRole
+      rsumManager = new RsumManager()
+      other play rsumManager
+      rsumManager.manageRsum(other)      
+    }
+  } 
+  
+  class BaseRole extends IRsumRole {
+    //deletion comes from down
+    private[model_management] def removeRole(): Unit = {
+      baseRole.remove()
+      otherRole.remove()
+      +IJoinCompartment.this deleteEverything()
+    }
+  }
+  
+  class OtherRole extends IRsumRole {
+    private[model_management] def removeRole(): Unit = {
+      baseRole.remove()
+      otherRole.remove()
+      +IJoinCompartment.this deleteEverything()
+    }
+  }
+  
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/join/IJoinInfo.scala b/src/main/scala/org/rosi_project/model_management/sum/join/IJoinInfo.scala
new file mode 100644
index 0000000000000000000000000000000000000000..8e25239072bc669b9a68896230e296ee5ba86e80
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/join/IJoinInfo.scala
@@ -0,0 +1,36 @@
+package org.rosi_project.model_management.sum.join
+
+trait IJoinInfo {
+  
+  private var allPlayers: Set[Object] = Set.empty
+  
+  def addObject(obj: Object): Unit = {
+    allPlayers = allPlayers + obj
+  }
+  
+  def removeObject(obj: Object): Unit = {
+    allPlayers = allPlayers - obj
+  }
+  
+  protected def objectInitialize(join: IJoinCompartment, base: Object, other: Object): Unit = {
+    join.objectInitialization(base, other)
+  }
+  
+  def containsObject(obj: Object): Boolean = allPlayers.contains(obj)
+  
+  def getJoinType(): RsumJoinType.Value  
+  
+  private def canInJoin(obj: Object): Boolean = (isInstanceBaseModel(obj) || isInstanceOtherModel(obj)) && !allPlayers.contains(obj)
+  
+  def canMatchWithNewJoin(obj: Object): Boolean = canInJoin(obj) && !containsObject(obj)
+  
+  def isInstanceBaseModel(obj: Object): Boolean
+  
+  def isInstanceOtherModel(obj: Object): Boolean
+  
+  def matchTwoObjects(b: Object, o: Object): Boolean
+  
+  def getNewInstance(b: Object, o: Object): IJoinCompartment
+  
+  def isInstanceOf(obj: Object): Boolean
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/join/RsumJoinType.scala b/src/main/scala/org/rosi_project/model_management/sum/join/RsumJoinType.scala
new file mode 100644
index 0000000000000000000000000000000000000000..709ec2eb28441f6d9ae579681c66e4542ec53521
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/join/RsumJoinType.scala
@@ -0,0 +1,5 @@
+package org.rosi_project.model_management.sum.join
+
+object RsumJoinType extends Enumeration {
+  val outer, natural, theta = Value
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/query/AQuery.scala b/src/main/scala/org/rosi_project/model_management/sum/query/AQuery.scala
new file mode 100644
index 0000000000000000000000000000000000000000..165cebcc276f8257703526c8ca8fc5d54c367da4
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/query/AQuery.scala
@@ -0,0 +1,102 @@
+package org.rosi_project.model_management.sum.query
+
+import scroll.internal.Compartment
+
+/**
+ * Describes the abstract query compartment with the roles that each query must implement.
+ */
+abstract class AQuery(val name: String) extends Compartment {
+  
+  def deleteQueryResults(): Unit
+  def deleteQueryObjects(): Unit
+  
+  /**
+   * Create ModelJoin syntax for views.
+   */
+  def generateModelJoinFromQuery(): String
+  
+  /**
+   * Add a query role to the underlying object.
+   */
+  def addQueryRole(obj: Object): AQuery#QueryObject
+  
+  /**
+   * Remove a query role from the query.
+   */
+  def removeQueryRole(role: AQuery#QueryObject): Unit
+  
+  /**
+   * Proof if the query has a correct form.
+   * Not more than one connection island.
+   */
+  def isQueryCorrect(): Boolean
+  
+  /**
+   * Running the query and getting a set of sets of result objects.
+   */
+  def runQuery(): Set[Set[Object]]
+  
+  /**
+   * Abstract query object to create the query from example.
+   */
+  abstract class QueryObject() {
+    
+    /**
+     * Label to identify a query object.
+     */
+    var label: String = ""
+    
+    /**
+     * Describes is necessary to be in the results or to be not.
+     */
+    var negated: Boolean = false
+    
+    /**
+     * Important to describe if a transitive closure should be created.
+     */
+    var transitive: Boolean = false
+    
+    /**
+     * Describes how often a connection must exists.
+     */
+    var multi: Int = 1
+    
+    /**
+     * Describes if the elements should be returned in the results or not.
+     */
+    var returned: Boolean = true
+    
+    private var attributeFilters: Set[AttributeFilter] = Set.empty
+      
+    /**
+  	 * Create and add an attribute filter object to a query object.
+   	 */        
+    def addAttributeFilter(attributeName: String, value: String, bigger: CheckingOption.Value): Boolean = {
+      if (attributeName == null || attributeName == "" ||
+        bigger == null || value == null || value == "") {
+        return false
+      }
+      attributeFilters += new AttributeFilter(attributeName, value, bigger)
+      return true
+    }
+    
+    def getAttributeFilters(): Set[AttributeFilter] = attributeFilters
+    
+    def overallConnectionUnit(): Int
+    
+    override def toString(): String = "QO: " + label
+  }  
+  
+  /**
+   * Abstract query results that each element which matches the query gets.
+   */
+  abstract class QueryResult(val matchedQueryObject: QueryObject) {
+    
+    override def toString(): String = "QR: (" + this.player.right.get.toString() + " " + matchedQueryObject + ")"
+  }
+  
+  /**
+   * Should collect information about the attributes a query element must have
+   */
+  class AttributeFilter(val attributeName: String, val value: String, val checking: CheckingOption.Value) {}
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/query/CheckingOption.scala b/src/main/scala/org/rosi_project/model_management/sum/query/CheckingOption.scala
new file mode 100644
index 0000000000000000000000000000000000000000..9d6ceffdbde34775bfb192b2607c44e582d23b77
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/query/CheckingOption.scala
@@ -0,0 +1,5 @@
+package org.rosi_project.model_management.sum.query
+
+object CheckingOption extends Enumeration {
+  val equalsCheck, biggerThan, smallerThan = Value
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/query/IQueryViewCompartment.scala b/src/main/scala/org/rosi_project/model_management/sum/query/IQueryViewCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..462693e2d5ad7b0d5cfb71ac15647523fed0130c
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/query/IQueryViewCompartment.scala
@@ -0,0 +1,138 @@
+package org.rosi_project.model_management.sum.query
+
+import scroll.internal.Compartment
+import scala.collection.mutable.ListBuffer
+import scala.collection.mutable.Set
+import org.rosi_project.model_management.core.RsumCompartment
+import org.rosi_project.model_management.sum.compartments.IRelationCompartment
+
+trait IQueryViewCompartment extends Compartment {
+  
+  private var name: String = ""
+  private var query: Query = null
+  
+  RsumCompartment.combine(this)
+  
+  protected def init(n: String): Unit = {
+    name = n
+    query = new Query(n)
+  }
+  
+  private var naturalRoles = Set[AQueryViewRole]()
+  private var relationalRoles = Set[AQueryViewRole]()
+  
+  def getName(): String = name
+  
+  def getQuery(): Query = query
+  
+  /**
+   * Get a map with the simple names of all elements 
+   * and the connected elements in the view.
+   */
+  def getMapOfElements(): Map[String, Set[AQueryViewRole]] = {
+    var result: Map[String, Set[AQueryViewRole]] = Map.empty
+    naturalRoles.foreach(n => {
+      if (result.contains(n.getClass.getSimpleName)) {
+        result(n.getClass.getSimpleName) += n
+      } else {
+        result = result + (n.getClass.getSimpleName -> Set(n))
+      }
+    })
+    result
+  }
+  
+  /**
+   * Get all elements with the specific simple name.
+   */
+  def getElementsWithClassName(s: String): Set[AQueryViewRole] = {
+    var result: Set[AQueryViewRole] = Set.empty
+    naturalRoles.foreach(n => {
+      if (n.getClass.getSimpleName == s) {
+        result += n
+      }
+    })
+    result
+  }  
+  
+  /**
+   * Get all elements with the same type from the view.
+   */
+  def getElementsWithExample[A <: AQueryViewRole](a: A): Set[A] = {
+    var result: Set[A] = Set.empty
+    naturalRoles.foreach(n => {
+      if (n.getClass.getName == a.getClass.getName) {
+        result += n.asInstanceOf[A]
+      }
+    })
+    result
+  }
+  
+  protected def getRoleFromList(classname: Object): AQueryViewRole = {
+    relationalRoles.foreach { r =>
+      if (+r == +classname) {
+        return r
+      }
+    }
+    naturalRoles.foreach { r =>
+      if (+r == +classname) {
+        return r
+      }
+    }
+    return null
+  }
+
+  def printViewRoles(): Unit = {
+    println("-------------------------------------------------------------------")
+    println("QueryView: " + name + " #Roles: " + naturalRoles.size)
+    naturalRoles.foreach { r =>
+      var player = r.player.right.get
+      var playerRoles = player.roles()
+      println("* Player: " + player + " - Role: " + r + " - Size: " + playerRoles.size)
+    }
+    relationalRoles.foreach { r =>
+      var player = r.player.right.get
+      var playerRoles = player.roles()
+      println("# Player: " + player + " - Role: " + r + " - Size: " + playerRoles.size)
+    }
+    println("-------------------------------------------------------------------")
+  }
+  
+  def getAllViewElements(): Set[AQueryViewRole] = naturalRoles
+  
+  def containsRole(role: AQueryViewRole): Boolean = naturalRoles.contains(role)
+  
+  abstract class AQueryViewRole {  
+    
+    protected var connected: AQuery#QueryObject = null 
+    
+    initializeElement()
+    
+    protected def isRelational(): Boolean
+    
+    protected def getCreationObject(): Object
+    
+    def getQueryObject: AQuery#QueryObject = connected  
+
+    private def initializeElement(): Unit = {
+      val obj = getCreationObject
+      if (isRelational) {
+        relationalRoles += this
+        val rel = obj.asInstanceOf[IRelationCompartment]
+        RsumCompartment.combine(rel)
+        rel.internalInitialize()
+      } else {
+        naturalRoles += this
+      }
+      connected = query.addQueryRole(obj)
+      obj play this
+    }      
+  
+    protected def deleteElement(): Unit = {
+      if (isRelational) {
+        +this deleteCompartment()
+      }
+      this.remove()
+      query.removeQueryRole(connected)
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/query/ModelJoinContainer.scala b/src/main/scala/org/rosi_project/model_management/sum/query/ModelJoinContainer.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a53ad57170d624c6c7596cb3de5a757734aab348
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/query/ModelJoinContainer.scala
@@ -0,0 +1,5 @@
+package org.rosi_project.model_management.sum.query
+
+class ModelJoinContainer(val name: String, val source: String, val target: String) {
+  
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/query/Query.scala b/src/main/scala/org/rosi_project/model_management/sum/query/Query.scala
new file mode 100644
index 0000000000000000000000000000000000000000..dbb13dfda29f19212701b034823bf10de8de5915
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/query/Query.scala
@@ -0,0 +1,624 @@
+package org.rosi_project.model_management.sum.query
+
+import scroll.internal.Compartment
+import org.rosi_project.model_management.core.RsumCompartment
+import org.rosi_project.model_management.sum.compartments.IRelationCompartment
+import org.rosi_project.model_management.sum.roles.IRelationRole
+import org.rosi_project.model_management.util.query.ModelJoinCreator
+import org.rosi_project.model_sync.model_join.representation.grammar.CompoundKeepBuilder
+
+/**
+ * Special query implementation for the query interface that works on the RSUM.
+ */
+class Query(_name: String) extends AQuery(_name) {
+  
+  RsumCompartment.combine(this)
+  
+  private var queryRelRoles: Set[QueryRelObject] = Set.empty
+  private var queryNatRoles: Set[QueryNatObject] = Set.empty
+  
+  private var queryRelResults: Set[QueryRelResult] = Set.empty
+  private var queryNatResults: Set[QueryNatResult] = Set.empty
+    
+  private def getQueryNatRole(obj: Object): QueryNatObject = {
+    //queryNatRoles.filter(+_ == +obj).foreach(return _)
+    queryNatRoles.foreach(q => {
+      if (+obj == +q) {
+        return q
+      }
+    })
+    return null
+  }
+    
+  private def getQueryRelRole(obj: Object): QueryRelObject = {
+    //queryRelRoles.filter(+_ == +obj).foreach(return _)
+    queryRelRoles.foreach(q => {
+      if (+obj == +q) {
+        return q
+      }
+    })
+    return null
+  }
+  
+  private def getNatResultRole(player: Object, queryObject: QueryNatObject): QueryNatResult = {
+    //queryNatResults.filter(r => r.connectedQueryObject == queryObject && +player == +r).foreach(return _)
+    queryNatResults.foreach(r => {
+      if (r.connectedQueryObject == queryObject && +player == +r) {
+        return r
+      }
+    })
+    return null
+  }
+  
+  def generateModelJoinFromQuery(): String = {
+    val creator = new ModelJoinCreator
+    /*val start = queryNatRoles.head
+    val playerStart: Object = start.player.right.get
+    playerStart.getClass.getPackage.getName
+    playerStart.getClass.getSimpleName*/
+    var relHelper: Set[ModelJoinContainer] = Set.empty
+    var relNames: Set[String] = Set.empty
+    var sources: Set[String] = Set.empty
+    var targets: Set[String] = Set.empty
+    
+    var names: Set[String] = Set.empty 
+    var connected: Map[String, Object] = Map()
+    
+    queryNatRoles.foreach(q => {
+      val playerStart: Object = q.player.right.get
+      println(playerStart.getClass.getName)
+      names += playerStart.getClass.getName      
+    })
+    queryRelRoles.foreach(q => {
+      val playerStart: Object = q.player.right.get
+      val playerSource: Object = q.source.player.right.get
+      val playerTarget: Object = q.target.player.right.get
+      println("+" + playerStart.getClass.getName)
+      println(playerSource.getClass.getName)
+      println(playerTarget.getClass.getName)
+      if (!relNames.contains(playerStart.getClass.getName)) {
+        relNames += playerStart.getClass.getName
+        sources += playerSource.getClass.getName
+        targets += playerTarget.getClass.getName
+        relHelper += new ModelJoinContainer(playerStart.getClass.getName, playerSource.getClass.getName, playerTarget.getClass.getName)
+        if (!connected.contains(playerSource.getClass.getName)) {
+          connected += (playerSource.getClass.getName -> creator.createNaturalJoin(playerSource.getClass.getName))
+        }
+        connected += (playerTarget.getClass.getName -> creator.createOutgoingReference(playerTarget.getClass.getName, playerStart.getClass.getSimpleName).asInstanceOf[Object])
+      }
+    })
+    
+    val start = sources.filter(!targets.contains(_)).head
+    val builder = creator.createNaturalJoin(start)
+    relHelper.filter(_.source == start).foreach(r => {
+      
+    })
+    ""
+  }
+  
+  def deleteQueryResults(): Unit = {
+    queryRelResults.foreach(_.remove())
+    queryRelResults = Set.empty
+    queryNatResults.foreach(_.remove())
+    queryNatResults = Set.empty
+  }  
+    
+  def deleteQueryObjects(): Unit = {
+    queryRelRoles.foreach(_.remove())
+    queryRelRoles = Set.empty
+    queryNatRoles.foreach(_.remove())
+    queryNatRoles = Set.empty
+  }
+  
+  def isQueryCorrect(): Boolean = {
+    //check if the query is correct and does not contain more close islands
+    queryRelRoles.foreach(qo => {
+      return qo.overallConnectionUnit() == (queryRelRoles.size + queryNatRoles.size)
+    })
+    queryNatRoles.foreach(qo => {
+      return qo.overallConnectionUnit() == (queryRelRoles.size + queryNatRoles.size)
+    })
+    return true
+  }
+  
+  def removeQueryRole(role: AQuery#QueryObject): Unit = {
+    if (role.isInstanceOf[QueryNatObject]) {
+      queryNatRoles -= role.asInstanceOf[QueryNatObject]
+    }
+    if (role.isInstanceOf[QueryRelObject]) {
+      queryRelRoles -= role.asInstanceOf[QueryRelObject]
+    }
+  }
+  
+  def addQueryRole(obj: Object): AQuery#QueryObject = {
+    val relResult = getQueryRelRole(obj)
+    if (relResult != null) return relResult
+    val natResult = getQueryNatRole(obj)
+    if (natResult != null) return natResult
+    //get player
+    val playerObj = obj.player.getOrElse(obj)
+    //difference between relation and natural
+    if (playerObj.isInstanceOf[IRelationCompartment]) {
+      val refComp = playerObj.asInstanceOf[IRelationCompartment]
+      this.combine(refComp)
+      val sourceRole: QueryNatObject = getQueryNatRole(refComp.getSource())
+      val targetRole: QueryNatObject = getQueryNatRole(refComp.getTarget())
+      if (sourceRole == null || targetRole == null) {
+        println("--- Error: Relational compartment can only be added if source and target are added before")
+        return null
+      }
+      val newRole = new QueryRelObject(sourceRole, targetRole)
+      queryRelRoles += newRole    
+      playerObj play newRole
+      return newRole
+    } else {
+      val newRole = new QueryNatObject()
+      queryNatRoles += newRole    
+      playerObj play newRole
+      return newRole
+    }  
+  }  
+  
+  def runQuery(): Set[Set[Object]] = {
+    //delete at the end
+    var forDeletionQueryResults: Set[QueryNatResult] = Set.empty
+    //immediate values
+    var deleteNatResults: Set[QueryNatResult] = Set.empty   
+    var doSomething = true
+    //output value
+    var result: Set[Set[Object]] = Set.empty
+    
+    //###add query results to all elements that can be results because of connection properties
+    //...iterate over non negated query relations and add result roles if necessary 
+    queryRelRoles.filter(!_.isNegated()).foreach(queryRel => {
+      val playerQueryRel: IRelationCompartment = queryRel.player.right.get.asInstanceOf[IRelationCompartment]
+      RsumCompartment.getRelations().foreach(rsumRel => {
+        if (playerQueryRel.getClass.isInstance(rsumRel)) {
+          //search if their are existing results if not create new ones
+          val rsumNatSource: Object = rsumRel.getSource().player.right.get
+          val rsumNatTarget: Object = rsumRel.getTarget().player.right.get
+          var queryNatResultSource: QueryNatResult = getNatResultRole(rsumNatSource, queryRel.source)
+          if (queryNatResultSource == null) {
+            queryNatResultSource = new QueryNatResult(queryRel.source)  
+            rsumNatSource play queryNatResultSource
+            queryNatResults += queryNatResultSource
+          }          
+          var queryNatResultTarget: QueryNatResult = getNatResultRole(rsumNatTarget, queryRel.target)
+          if (queryNatResultTarget == null) {
+            queryNatResultTarget = new QueryNatResult(queryRel.target)  
+            rsumNatTarget play queryNatResultTarget
+            queryNatResults += queryNatResultTarget
+          }
+          //connect them in a new relation result
+          val queryRelResult: QueryRelResult = new QueryRelResult(queryRel, queryNatResultSource, queryNatResultTarget, false) 
+          rsumRel play queryRelResult     
+          queryRelResults += queryRelResult
+          
+          //if transitive add new relation to separate list to add them at the end
+          if (queryRel.isTransitive) {
+            //set only source new because target must be old one, transitive query means always target same
+            queryNatResultSource = getNatResultRole(rsumNatSource, queryRel.target)
+            if (queryNatResultSource == null) {
+              queryNatResultSource = new QueryNatResult(queryRel.target)  
+              rsumNatSource play queryNatResultSource
+              queryNatResults += queryNatResultSource
+            }
+            val transitiveQueryRelResult: QueryRelResult = new QueryRelResult(queryRel, queryNatResultSource, queryNatResultTarget, true) 
+            rsumRel play transitiveQueryRelResult     
+            queryRelResults += transitiveQueryRelResult
+          }
+        }
+      })      
+    })
+    
+    //...iterate over negated related roles and search all opposite naturals that do not implement this rel
+    queryRelRoles.filter(_.isNegated()).foreach(queryRel => {
+      val playerQueryRel: IRelationCompartment = queryRel.player.right.get.asInstanceOf[IRelationCompartment]
+      var playerQueryNat: Object = null
+      if (queryRel.source.negated) {
+        playerQueryNat = playerQueryRel.getSource.player.right.get 
+      } else {
+        playerQueryNat = playerQueryRel.getTarget.player.right.get 
+      }
+      //source or target negated, search for negated class
+      RsumCompartment.getNaturals().foreach(rsumNat => {
+        if (playerQueryNat.getClass.isInstance(rsumNat))
+        {
+          var goodElement: Boolean = true;
+          //filtered roles of the natural type
+          var roles: Set[IRelationRole] = Set.empty 
+          if (queryRel.source.negated) {
+            roles = rsumNat.roles().filter(_.isInstanceOf[IRelationCompartment#ITarget]).toSet.asInstanceOf[Set[IRelationRole]] 
+          } else {
+            roles = rsumNat.roles().filter(_.isInstanceOf[IRelationCompartment#ISource]).toSet.asInstanceOf[Set[IRelationRole]] 
+          }
+          //if we find a role that works than we can not add this natural to the results
+          roles.foreach(r => {            
+            val outerRelComp = r.getOuterCompartment()
+            //println("COMP: " + outerRelComp + " " + playerQueryRel + " " + playerQueryRel.getClass.isInstance(outerRelComp))
+            if (playerQueryRel.getClass.isInstance(outerRelComp)) {
+              //we can not use this element
+              goodElement = false
+            }
+          })
+          //if we do not find a compatible element in this natural role we can add it
+          if (goodElement) {
+            var queryNatRole: QueryNatObject = null
+            if (queryRel.source.negated) {
+              queryNatRole = queryRel.target            
+            } else {
+              queryNatRole = queryRel.source
+            }
+            var queryNatResult: QueryNatResult = getNatResultRole(rsumNat, queryNatRole)
+            if (queryNatResult == null) {
+              queryNatResult = new QueryNatResult(queryNatRole) 
+              rsumNat play queryNatResult
+              queryNatResults += queryNatResult
+            }
+            if (queryRel.source.negated) {
+              queryNatResult.increaseTargetNegated()
+            } else {
+              queryNatResult.increaseSourceNegated()
+            }          
+          }
+        }
+      })
+    })    
+    
+    //...iterate over all query naturals without a connection and add result roles if necessary
+    queryNatRoles.filter(_.connectionSize == 0).foreach(queryNat => {
+      //connected one are visited in the part before
+      val playerQueryNat: Object = queryNat.player.right.get
+      RsumCompartment.getNaturals().foreach(rsumNat => {
+        if (playerQueryNat.isInstanceOf[QueryHelper]) {
+          if (playerQueryNat.equals(rsumNat)) {
+            var queryNatResult: QueryNatResult = getNatResultRole(rsumNat, queryNat)
+            if (queryNatResult == null) {
+              queryNatResult = new QueryNatResult(queryNat)  
+              rsumNat play queryNatResult
+              queryNatResults += queryNatResult
+            }
+          }
+        } else {
+          if (playerQueryNat.getClass.isInstance(rsumNat)) {
+            var queryNatResult: QueryNatResult = getNatResultRole(rsumNat, queryNat)
+            if (queryNatResult == null) {
+              queryNatResult = new QueryNatResult(queryNat)  
+              rsumNat play queryNatResult
+              queryNatResults += queryNatResult
+            }
+          }
+        }        
+      })
+    })
+    
+    //###proof correctness of results
+    //...proof attribute correctness once
+    queryNatResults.filter(!_.proofAttributes).foreach(deleteNatResults += _)
+    //delete them
+    deleteNatResults.foreach(queryResultNat => {
+      queryNatResults -= queryResultNat
+      forDeletionQueryResults += queryResultNat
+      queryResultNat.removeConnections()
+    })
+    
+    //...proof the correctness of the query results and delete non correct ones
+    while (doSomething) {
+      deleteNatResults = Set.empty      
+      //proof the connection correctness
+      queryNatResults.filter(!_.proofConnections).foreach(deleteNatResults += _)
+      
+      //do as long as everything is correct
+      doSomething = !deleteNatResults.isEmpty
+      //delete them
+      deleteNatResults.foreach(queryResultNat => {
+        queryNatResults -= queryResultNat
+        forDeletionQueryResults += queryResultNat
+        queryResultNat.removeConnections()   
+      })
+    }
+    
+    //###make good outputs from the current query results
+    //...only correct elements should now play result roles and are in the list    
+    var combinedResult: Set[QueryCombinedResult] = queryRelResults.filter(!_.transitive).map(_.createCombinedResult())
+    
+    //...combine the result elements to good output units
+    doSomething = true
+    while (doSomething) {
+      doSomething = false
+      combinedResult.foreach(combined => {
+        queryRelResults.foreach(rel => {
+          if (rel.source == combined.target && !combined.contains(rel.target)) {
+            //add in the back
+            combined.addBack(rel.target)
+            doSomething = true
+          } else {
+            if (rel.target == combined.source && !combined.contains(rel.source)) {
+              //add in the front
+              combined.addFront(rel.source)
+              doSomething = true
+            }            
+          }
+        })    
+      })  
+      //delete duplicated elements
+      combinedResult = combinedResult.groupBy(_.getBetween).map(_._2.head).toSet
+      //combinedResult.distinct
+    }
+    
+    //create only results with tuples
+    /*queryRelResults.foreach(rel => {
+      var rSet: Set[Object] = Set.empty
+      if (rel.source.connectedQueryObject.returned) {
+        rSet += rel.source.player.right.get
+      }
+      if (rel.target.connectedQueryObject.returned) {
+        rSet += rel.target.player.right.get
+      }
+      result += rSet
+    })*/
+    
+    //...bring the output format to the reals one
+    combinedResult.foreach(combined => {
+      var rSet: Set[Object] = Set.empty
+      combined.getBetween.foreach(queryNat => {
+        if (queryNat.connectedQueryObject.returned) {
+          rSet += queryNat.player.right.get
+        }
+      })
+      result += rSet
+    })
+    
+    //...add also single results
+    queryNatResults.foreach(queryResultNat => {
+      if (!queryResultNat.isConnected() && queryResultNat.connectedQueryObject.returned) {
+        result += Set(queryResultNat.player.right.get)
+      }
+    })
+    
+    //...delete now really all not needed result roles 
+    forDeletionQueryResults.foreach(_.remove())
+    
+    return result
+  }
+  
+  override def toString(): String = name + ": " + isQueryCorrect + " Rs: " + queryNatRoles + " " + queryRelRoles
+  
+  /**
+   * Query object specialized for naturals in the RSUM.
+   */
+  class QueryNatObject() extends QueryObject() {
+    private var sourceRelations: Set[QueryRelObject] = Set.empty
+    private var targetRelations: Set[QueryRelObject] = Set.empty    
+    
+    def addSourceRelation(rel: QueryRelObject): Unit = {
+      sourceRelations += rel
+    }    
+    
+    def removeSourceRelation(rel: QueryRelObject): Unit = {
+      sourceRelations -= rel
+    }
+    
+    def getSourceRelationsSize(): Int = sourceRelations.filter(!_.isNegated()).map(_.multiTarget).sum //sum up multi value not use size
+    def getNegatedSourceRelationsSize(): Int = sourceRelations.filter(_.isNegated()).size
+    
+    def addTargetRelation(rel: QueryRelObject): Unit = {
+      targetRelations += rel
+    }
+    
+    def removeTargetRelation(rel: QueryRelObject): Unit = {
+      targetRelations -= rel
+    }
+    
+    def getTargetRelationsSize(): Int = targetRelations.filter(!_.isNegated()).map(_.multiSource).sum
+    def getNegatedTargetRelationsSize(): Int = targetRelations.filter(_.isNegated()).size
+    
+    def connectionSize(): Int = targetRelations.size + sourceRelations.size
+    
+    def overallConnectionUnit(): Int = {
+      var visitedRel: Set[QueryRelObject] = Set.empty
+      var visitedNat: Set[QueryNatObject] = Set(this)
+      var unVisitedRel: Set[QueryRelObject] = targetRelations ++ sourceRelations
+      var unVisitedNat: Set[QueryNatObject] = Set.empty
+      while (!unVisitedRel.isEmpty || !unVisitedNat.isEmpty) {
+        //run over all unvisited relations 
+        unVisitedRel.foreach(rel => {
+          if (!visitedNat.contains(rel.source))
+            unVisitedNat += rel.source 
+          if (!visitedNat.contains(rel.target))
+            unVisitedNat += rel.target
+        })
+        visitedRel ++= unVisitedRel
+        unVisitedRel = Set.empty
+        //run over all unvisited naturals 
+        unVisitedNat.foreach(nat => {
+          nat.sourceRelations.filter(!visitedRel.contains(_)).foreach(unVisitedRel += _)
+          nat.targetRelations.filter(!visitedRel.contains(_)).foreach(unVisitedRel += _)
+        })
+        visitedNat ++= unVisitedNat
+        unVisitedNat = Set.empty        
+      }
+      return visitedRel.size + visitedNat.size
+    }
+    
+    override def toString: String = "QON: " + label + " C: " + connectionSize
+  }
+    
+  /**
+   * Query object specialized for relational compartments in the RSUM.
+   */
+  class QueryRelObject(val source: QueryNatObject, val target: QueryNatObject) extends QueryObject() {
+
+    def isNegated(): Boolean = source.negated || target.negated
+    def isTransitive(): Boolean = target.transitive
+    def multiTarget(): Int = target.multi
+    def multiSource(): Int = source.multi
+    
+    source.addSourceRelation(this)
+    target.addTargetRelation(this)
+    
+    def overallConnectionUnit(): Int = source.overallConnectionUnit()
+    
+    override def toString: String = "QOR: " + source.label + "-" + target.label
+  }
+    
+  /**
+   * Query result roles for natural query roles.
+   */
+  class QueryNatResult(val connectedQueryObject: QueryNatObject) extends QueryResult(connectedQueryObject) {
+    private var sourceRelations: Set[QueryRelResult] = Set.empty
+    private var targetRelations: Set[QueryRelResult] = Set.empty
+    
+    private var negatedSources: Int = 0
+    private var negatedTargets: Int = 0
+    
+    def increaseSourceNegated(): Unit = { negatedSources += 1 }
+    def decreaseSourceNegated(): Unit = { negatedSources -= 1 }
+    
+    def increaseTargetNegated(): Unit = { negatedTargets += 1 }
+    def decreaseTargetNegated(): Unit = { negatedTargets -= 1 }
+    
+    /**
+     * Proof if the player has all the necessary attributes with its values.
+     */
+    def proofAttributes(): Boolean = {
+      val player: Object = this.player.right.get   
+      var returnValue = true 
+      connectedQueryObject.getAttributeFilters.foreach(a => {
+        try {
+          //player.getClass.getMethods.foreach(f => println(f.toString))
+          //println(player.getClass.getMethod("name").getReturnType) //getName
+          val met = player.getClass.getMethod(a.attributeName)        
+          val result: String = met.invoke(player).asInstanceOf[String]
+          a.checking match {
+            case CheckingOption.equalsCheck => if (result != a.value) returnValue = false
+            case CheckingOption.biggerThan => if (result <= a.value) returnValue = false
+            case CheckingOption.smallerThan => if (result >= a.value) returnValue = false
+            case _ =>
+          }
+        } catch {
+          case _: Throwable => { 
+            println("!!! No attribute with this name!!!") 
+            return false
+          }
+        }
+      })
+      return returnValue
+    }
+    
+    /**
+     * Proof if the number of connections is equals to the related query object.
+     */
+    def proofConnections(): Boolean = {
+      //TODO: proof also the number of types and not only the numbers
+      //println("S: " + _connectedQueryObject.getSourceRelationsSize() + " T: " + _connectedQueryObject.getTargetRelationsSize() + " NS: " + _connectedQueryObject.getNegatedSourceRelationsSize() + " NT: " + _connectedQueryObject.getNegatedTargetRelationsSize() + " Con: " + _connectedQueryObject)
+      //println("S: " + getSourceRelationsSize() + " T: " + getTargetRelationsSize() + " NS: " + negatedSources + " NT: " + negatedTargets + " This: " + this)
+      if (getSourceRelationsSize >= connectedQueryObject.getSourceRelationsSize() 
+          && getTargetRelationsSize >= connectedQueryObject.getTargetRelationsSize()
+          && negatedSources >= connectedQueryObject.getNegatedSourceRelationsSize()
+          && negatedTargets >= connectedQueryObject.getNegatedTargetRelationsSize()) {
+        return true
+      }
+      return false
+    }
+    
+    def addSourceRelation(rel: QueryRelResult): Unit = {
+      sourceRelations += rel
+    }
+    
+    def removeSourceRelation(rel: QueryRelResult): Unit = {
+      sourceRelations -= rel
+    }
+    
+    def getSourceRelationsSize(): Int = sourceRelations.size
+    
+    def addTargetRelation(rel: QueryRelResult): Unit = {
+      targetRelations += rel
+    }
+    
+    def removeTargetRelation(rel: QueryRelResult): Unit = {
+      targetRelations -= rel
+    }
+    
+    def getTargetRelationsSize(): Int = targetRelations.size
+        
+    def isConnected(): Boolean = (targetRelations.size + sourceRelations.size) > 0
+    
+    def removeConnections(): Unit = {
+      sourceRelations.foreach(rel => {        
+        rel.target.removeTargetRelation(rel)
+        queryRelResults -= rel
+        rel.remove()
+      })      
+      targetRelations.foreach(rel => {        
+        rel.source.removeSourceRelation(rel)
+        queryRelResults -= rel
+        rel.remove()
+      })
+      sourceRelations = Set.empty
+      targetRelations = Set.empty    
+      negatedSources = 0
+      negatedTargets = 0
+    }
+  }
+  
+  /**
+   * Query result roles for relation query roles.
+   */
+  class QueryRelResult(val connectedQueryObject: QueryRelObject, val source: QueryNatResult, val target: QueryNatResult, val transitive: Boolean) extends QueryResult(connectedQueryObject) {
+    //only add this relation to the connect results if it is not transitive
+    if (!transitive) {
+      source.addSourceRelation(this)
+      target.addTargetRelation(this)
+    }
+    
+    /**
+     * Create a new combined result which is a copy of this one.
+     */
+    def createCombinedResult(): QueryCombinedResult = new QueryCombinedResult(source, target)
+  }
+  
+  /**
+   * Helper class to connect the results to a chain.
+   */
+  class QueryCombinedResult(var source: QueryNatResult, var target: QueryNatResult) {
+    
+    //list of all query results that are connected
+    private var between: Seq[QueryNatResult] = Seq(source, target)
+    
+    def getBetween(): Seq[QueryNatResult] = between
+    
+    def addFront(newIn: QueryNatResult): Unit = {
+      between = newIn +: between
+      source = newIn
+    }
+    
+    def addBack(newIn: QueryNatResult): Unit = {
+      between = between :+ newIn
+      target = newIn
+    }
+    
+    def contains(result: QueryNatResult): Boolean = ( between.contains(result) )
+    
+    private def getSize(): Int = between.size    
+    
+    protected def canEqual(other: Any): Boolean = other.isInstanceOf[QueryCombinedResult]
+    
+    override def equals(other: Any): Boolean = other match {
+      case that: QueryCombinedResult => {
+        if (that canEqual this) {
+          between.foreach(b => {
+            if (!that.contains(b))
+              return false
+          })
+          return that.getSize == this.getSize()
+        } else {
+          return false
+        }
+      }
+      case _ => return false
+    }
+    
+    override def toString(): String = "QCR: (" + between + ")"
+  }  
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/query/QueryHelper.scala b/src/main/scala/org/rosi_project/model_management/sum/query/QueryHelper.scala
new file mode 100644
index 0000000000000000000000000000000000000000..496be488f8cdb4f49d0f80379621ff42d2a5f11f
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/query/QueryHelper.scala
@@ -0,0 +1,5 @@
+package org.rosi_project.model_management.sum.query
+
+trait QueryHelper {
+  
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/roles/IExtensionRole.scala b/src/main/scala/org/rosi_project/model_management/sum/roles/IExtensionRole.scala
new file mode 100644
index 0000000000000000000000000000000000000000..ed7738fd16ffa75539bbf2467e71de22d4fb56e6
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/roles/IExtensionRole.scala
@@ -0,0 +1,6 @@
+package org.rosi_project.model_management.sum.roles
+
+trait IExtensionRole extends IRsumRole {
+  
+  def runExtension() : Unit
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/roles/IRelationRole.scala b/src/main/scala/org/rosi_project/model_management/sum/roles/IRelationRole.scala
new file mode 100644
index 0000000000000000000000000000000000000000..20e4c62f611fe1324a4f4148b7e2379ea7a7bd70
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/roles/IRelationRole.scala
@@ -0,0 +1,9 @@
+package org.rosi_project.model_management.sum.roles
+
+import org.rosi_project.model_management.sum.compartments.IRelationCompartment
+
+trait IRelationRole extends IRsumRole {
+  
+  //TODO: look if this method needs different visibility
+  def getOuterCompartment() : IRelationCompartment
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/roles/IRsumRole.scala b/src/main/scala/org/rosi_project/model_management/sum/roles/IRsumRole.scala
new file mode 100644
index 0000000000000000000000000000000000000000..e0a13d08b1f3a6a1805d2cac83e5247a0b46e313
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/roles/IRsumRole.scala
@@ -0,0 +1,6 @@
+package org.rosi_project.model_management.sum.roles
+
+trait IRsumRole {
+  
+  private[model_management] def removeRole(): Unit
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sum/roles/IViewRole.scala b/src/main/scala/org/rosi_project/model_management/sum/roles/IViewRole.scala
new file mode 100644
index 0000000000000000000000000000000000000000..73093fcd9ba9a909ce2a3450d7bb7dbdb3fa48bb
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sum/roles/IViewRole.scala
@@ -0,0 +1,5 @@
+package org.rosi_project.model_management.sum.roles
+
+trait IViewRole extends IRsumRole {
+      
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sync/IConstructionCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/IConstructionCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..9fd3371b4dd9d92a12b6bf21bd05a8131488757f
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/IConstructionCompartment.scala
@@ -0,0 +1,161 @@
+package org.rosi_project.model_management.sync
+
+import scroll.internal.Compartment
+
+import org.rosi_project.model_management.core._
+import org.rosi_project.model_management.sync.helper.ConstructionContainer
+import org.rosi_project.model_management.sync.roles.IConstructor
+
+/**
+ * Interface for each construction rule.
+ */
+trait IConstructionCompartment extends Compartment {
+
+  /**
+   * Return a role instance that handles the construction process for the object.
+   */
+  def getConstructorForClassName(classname: Object): IConstructor
+
+  def getRuleName: String
+
+  private def addExtensionRoles(containers: Set[ConstructionContainer]): Unit = {
+    containers.foreach { cc =>
+      if (cc.isConstructed) {
+        SynchronizationCompartment.getExtensions().foreach { e =>
+          var role = e.getExtensionForClassName(cc.getPlayerInstance())
+          if (role != null) {
+            cc.getManagerInstance() play role
+          }
+        }
+      }
+    }
+  }
+
+  private def notifyExtensionRoles(containers: Set[ConstructionContainer]): Unit = {
+    if (!SynchronizationCompartment.getExtensions().isEmpty) {
+      containers.foreach { cc =>
+        if (cc.isConstructed) {
+          var playerInstance = cc.getPlayerInstance()
+          +playerInstance insertNotification ()
+        }
+      }
+    }
+  }
+
+  /**
+   * Add the RoleManager roles from the synchronization compartment if necessary
+   */
+  protected def addManagerRoles(containers: Set[ConstructionContainer]): Unit = {
+    containers.foreach { cc =>
+      if (cc.isConstructed && !cc.isStartElement) {
+        cc.getPlayerInstance play cc.getManagerInstance
+      }
+    }
+  }
+
+  /**
+   * Add the delete roles for the elements in the ConstructionContainers.
+   */
+  protected def addDeleteRoles(containers: Set[ConstructionContainer]): Unit = {
+    containers.foreach { cc =>
+      if (cc.isConstructed) {
+        cc.getManagerInstance() play SynchronizationCompartment.getDestructionRule().getDestructorForClassName(cc.getPlayerInstance())
+      }
+    }
+  }
+
+  /**
+   * Add the related RoleManagers for the elements in the ConstructionContainers.
+   */
+  protected def addRelatedRoleManager(containers: Set[ConstructionContainer]): Unit = {
+    containers.foreach { cc =>
+      containers.foreach { inner =>
+        cc.getManagerInstance.addRelatedManager(inner.getManagerInstance)
+      }
+    }
+  }
+
+  /**
+   * Combine the SynchronizationCompartment with all Players from the ConstructionContainers.
+   */
+  protected def synchronizeCompartments(containers: Set[ConstructionContainer]): Unit = {
+    containers.foreach { cc =>
+      if (cc.isConstructed() && !cc.isStartElement()) {
+        SynchronizationCompartment combine cc.getPlayerInstance
+      }
+    }
+  }
+
+  /**
+   * Create the Synchronization mechanisms for the elements in the ConstructionContainers.
+   */
+  protected def bindSynchronizationRules(containers: Set[ConstructionContainer]): Unit = {
+    SynchronizationCompartment.getSyncRules().foreach { s =>
+      var sync: ISyncCompartment = null
+      //Proof all container for integration
+      containers.foreach { cc =>
+        if (s.isNextIntegration(cc.getPlayerInstance)) {
+          if (cc.isConstructed && sync == null) {
+            sync = s.getNewInstance
+          }
+          if (sync != null) {
+            cc.getManagerInstance() play sync.getNextIntegrationRole(cc.getPlayerInstance())
+          }
+        }
+      }
+      if (sync != null)
+        SynchronizationCompartment combine sync
+    }
+  }
+
+  /**
+   * Fill the test lists with all Players from the ConstructionContainers.
+   */
+  protected def fillTestLists(containers: Set[ConstructionContainer]): Unit = {
+    containers.foreach { cc =>
+      ModelElementLists.addElement(cc.getPlayerInstance)
+    }
+  }
+
+  protected def makeCompleteConstructionProcess(containers: Set[ConstructionContainer]): Unit = {
+    //first synchronize new compartments
+    //var t1 = System.nanoTime()
+    this.synchronizeCompartments(containers)
+    //var t2 = System.nanoTime()
+
+    //add role manager and relations
+    this.addManagerRoles(containers)
+    //var t3 = System.nanoTime()
+    this.addRelatedRoleManager(containers)
+    //var t4 = System.nanoTime()
+
+    //binding of roles
+    //this.addDeleteRoles(containers)
+    this.bindSynchronizationRules(containers)
+    //var t5 = System.nanoTime()
+    this.addExtensionRoles(containers)
+    //var t6 = System.nanoTime()
+
+    //notify extensions
+    this.notifyExtensionRoles(containers)
+    //var t7 = System.nanoTime()
+
+    //fill test list
+    this.fillTestLists(containers)
+    /*var t8 = System.nanoTime()
+    println("1: " + (t2 - t1))
+    println("2: " + (t3 - t2))
+    println("3: " + (t4 - t3))
+    println("4: " + (t5 - t4))
+    println("5: " + (t6 - t5))
+    println("6: " + (t7 - t6))
+    println("7: " + (t8 - t7))*/
+
+    /*println("Construction ++++++++++++++++++++++++++++++++++++++++++++------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++")
+    containers.foreach { cc =>
+      println((cc.getPlayerInstance).roles())
+    }
+    println("Construction ++++++++++++++++++++++++++++++++++++++++++++------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++")*/
+  }
+
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/IDestructionCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/IDestructionCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..4034957981624c1ca7c25538e458ffb2d26cfa97
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/IDestructionCompartment.scala
@@ -0,0 +1,18 @@
+package org.rosi_project.model_management.sync
+
+import org.rosi_project.model_management.sync.roles.IDestructor
+import scroll.internal.Compartment
+
+/**
+  * Interface for each destruction rule.
+  */
+trait IDestructionCompartment extends Compartment {
+
+  /**
+    * Return a role instance that handles the destruction process for the object.
+    */
+  def getDestructorForClassName(classname: Object) : IDestructor
+  
+  def getRuleName: String
+  
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/IExtenstionCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/IExtenstionCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..ffa94fa6e36d2ebf305cf2d9eee928a56d2667b8
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/IExtenstionCompartment.scala
@@ -0,0 +1,20 @@
+package org.rosi_project.model_management.sync
+
+import org.rosi_project.model_management.sync.roles.IExtension
+import scroll.internal.Compartment
+
+/**
+  * Interface for each extension rule.
+  */
+trait IExtenstionCompartment extends Compartment {
+  
+  /**
+    * Return a role instance that handles the extension process for the object.
+    */
+  def getExtensionForClassName(classname: Object) : IExtension
+  
+  /**
+   * Return a unique name that describes this extension.
+   */
+  def getExtensionName() : String
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sync/IIntegrationCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/IIntegrationCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..6ab5927310221b277d402980651b563829795b52
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/IIntegrationCompartment.scala
@@ -0,0 +1,198 @@
+package org.rosi_project.model_management.sync
+
+import scroll.internal.Compartment
+import org.rosi_project.model_management.sync.roles.ISyncRole
+import org.rosi_project.model_management.sync.roles.IIntegrator
+import org.rosi_project.model_management.sync.helper.IntegrationContainer
+import org.rosi_project.model_management.core._
+import org.rosi_project.model_management.sync.roles.IRoleManager
+
+/**
+ * Interface for each integration rule.
+ */
+trait IIntegrationCompartment extends Compartment {
+
+  /**
+   * Return a role instance that handles the integration process for a new model to this instance.
+   */
+  def getIntegratorForClassName(classname: Object): IIntegrator
+
+  /**
+   * Return a role instance that handles the integration process for a new relational compartment.
+   */
+  def getRelationalIntegratorsForClassName(classname: Object): IIntegrator
+
+  def finalEditFunction(): Unit
+
+  protected def connectTargetElementWithSourceElementes(target: PlayerSync, sourceList: Set[PlayerSync]): Unit = {
+    var containers: Set[IntegrationContainer] = Set.empty
+    //Create Containers
+    sourceList.foreach(e => {
+      containers += new IntegrationContainer(target, e)
+    })
+    //Finish Creation
+    makeCompleteIntegrationProcess(containers)
+  }
+
+  protected def connectTargetElementWithSourceElemente(target: PlayerSync, source: PlayerSync): Unit = {
+    var containers: Set[IntegrationContainer] = Set.empty
+    //Create Container
+    containers += new IntegrationContainer(target, source)
+    //Finish Creation
+    makeCompleteIntegrationProcess(containers)
+  }
+
+  private def addExtensionRoles(containers: Set[IntegrationContainer]): Unit = {
+    containers.filter(_.newManagerConnection).foreach { cc =>
+      SynchronizationCompartment.getExtensions().foreach { e =>
+        var role = e.getExtensionForClassName(cc.getNewPlayerInstance())
+        if (role != null) {
+          cc.getNewManagerInstance() play role
+        }
+      }
+    }
+  }
+
+  private def notifyExtensionRoles(containers: Set[IntegrationContainer]): Unit = {
+    if (!SynchronizationCompartment.getExtensions().isEmpty) {
+      containers.filter(_.newManagerConnection).foreach { cc =>
+        var playerInstance = cc.getNewPlayerInstance()
+        +playerInstance insertNotification ()
+      }
+    }
+  }
+
+  /**
+   * Add Manager roles to all constructed elements.
+   */
+  private def addManagerRoles(containers: Set[IntegrationContainer]): Unit = {
+    containers.filter(_.newManagerConnection).foreach { cc =>
+      cc.getNewPlayerInstance() play cc.getNewManagerInstance()
+    }
+  }
+
+  /**
+   * Add the delete roles for the elements in the IntegrationContainer.
+   */
+  private def addDeleteRoles(containers: Set[IntegrationContainer]): Unit = {
+    containers.filter(_.newManagerConnection).foreach { cc =>
+      cc.getNewManagerInstance() play SynchronizationCompartment.getDestructionRule().getDestructorForClassName(cc.getNewPlayerInstance())
+    }
+  }
+
+  /**
+   * Add the related RoleManagers for the elements in the IntegrationContainer.
+   */
+  private def addRelatedRoleManager(containers: Set[IntegrationContainer]): Unit = {
+    containers.foreach { cc =>
+      val oldPlayer = cc.getOldPlayerInstance()
+      if (cc.simpleRelatedManagerConnection) {
+        val manager: IRoleManager = +oldPlayer getManager ()
+        if (manager != null) {
+          manager.makeRelated(cc.getNewManagerInstance())
+        }
+      } else {
+        val allManager: Set[IRoleManager] = +oldPlayer getAllManager ()
+        if (allManager != null) {
+          allManager.foreach { r =>
+            r.makeRelated(cc.getNewManagerInstance())
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Combine the SynchronizationCompartment with all Players from the IntegrationContainer.
+   */
+  private def synchronizeCompartments(containers: Set[IntegrationContainer]): Unit = {
+    containers.filter(_.newManagerConnection).foreach { cc =>
+      SynchronizationCompartment combine cc.getNewPlayerInstance()
+    }
+  }
+
+  /**
+   * Create the Synchronization mechanisms for the elements in the IntegrationContainer.
+   */
+  private def bindSynchronizationRules(containers: Set[IntegrationContainer]): Unit = {
+    containers.filter(_.newManagerConnection).foreach { cc =>
+      val oldPlayer = cc.getOldPlayerInstance()
+      val allManager: Set[IRoleManager] = +oldPlayer getAllManager ()
+      if (allManager != null) {
+        allManager.foreach { rm =>
+          val roles = rm.roles()
+          //println("Player: " + rm.player + "Roles: " + roles)
+          roles.foreach { r =>
+            if (r.isInstanceOf[ISyncRole]) {
+              val syncRole: ISyncRole = r.asInstanceOf[ISyncRole]
+              val syncComp: ISyncCompartment = syncRole.getOuterCompartment
+              //println("+~~~Sync: " + syncRole + " " + syncComp)
+              if (!syncComp.containsSyncer(cc.getNewPlayerInstance()) && syncComp.isFirstIntegration(r.player.right.get)) {
+                val newRole = syncComp.getNextIntegrationRole(cc.getNewPlayerInstance())
+                //println("+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~New Role: " + newRole)
+                if (newRole != null) {
+                  cc.getNewManagerInstance() play newRole
+                  allManager.foreach { internalSync =>
+                    val playerSync = internalSync.player.right.get
+                    if (syncComp.isNextIntegration(playerSync)) {
+                      if (!syncComp.containsSyncer(playerSync)) {
+                        internalSync play syncComp.getNextIntegrationRole(playerSync)
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Fill the test lists with all Players from the IntegrationContainer.
+   */
+  private def fillTestLists(containers: Set[IntegrationContainer]): Unit = {
+    containers.filter(_.newManagerConnection).foreach { cc =>
+      ModelElementLists.addElement(cc.getNewPlayerInstance())
+    }
+  }
+
+  /**
+   * Do the integration process automatically.
+   */
+  protected def makeCompleteIntegrationProcess(containers: Set[IntegrationContainer]): Unit = {
+    containers.foreach(cc => {
+      if (cc.getNewManagerInstance() == null) {
+        val newPlayer = cc.getNewPlayerInstance()
+        val manager = +newPlayer getManager ()
+        if (manager.isRight && manager.right.get != null) {
+          cc.newManagerConnection = false
+          cc.newManagerInstance = manager.right.get
+        } else {
+          cc.newManagerConnection = true
+          cc.newManagerInstance = SynchronizationCompartment.createRoleManager()
+        }
+      }
+    })
+
+    //add new role managers to the new players
+    this.addManagerRoles(containers)
+    //this.addDeleteRoles(containers)
+    this.addRelatedRoleManager(containers)
+    //combines the new compartments with the existing ones
+    this.synchronizeCompartments(containers)
+    this.bindSynchronizationRules(containers)
+    //add extension roles and notify them because of creation
+    this.addExtensionRoles(containers)
+    this.notifyExtensionRoles(containers)
+    //add the new model element to the elements list
+    this.fillTestLists(containers)
+    /*println("Integrate +++++++++++++++++++++++++++++++++++++++++++++---------------------------------------------+++++++++++++++++++++++++++++++++++++++++++++++++++")
+    containers.foreach { cc =>
+      println((cc.getNewPlayerInstance()).roles())
+      println((cc.getOldPlayerInstance()).roles())
+    }
+    println("Integrate ++++++++++++++++++++++++++++++++++++++++++++------------------------++++++++++++++++++++++++++++++++++++++++++++++++++++")*/
+  }
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/ISyncCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/ISyncCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..4b50e08618dcc668fb9c5f44e45c05ef1e7a02c4
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/ISyncCompartment.scala
@@ -0,0 +1,101 @@
+package org.rosi_project.model_management.sync
+
+import org.rosi_project.model_management.sync.roles.ISyncRole
+import scroll.internal.Compartment
+
+import scala.collection.immutable.Set
+
+/**
+  * Interface for each synchronization rule.
+  */
+trait ISyncCompartment extends Compartment {
+
+  /**
+    * Variable to proof if he is actual in a sync process.
+    */
+  protected var doSync = false
+  /**
+    * All sync roles of this synchronization rule.
+    */
+  private var syncer: Set[ISyncRole] = Set.empty
+
+  /**
+    * Get roles for all integration classes.
+    */
+  protected def getNextRole(classname: Object) : ISyncRole = {
+    getFirstRole(classname)
+  }
+  
+  /**
+    * Get roles for integration classes. Should give less roles than getNextRole.
+    */
+  protected def getFirstRole(classname: Object) : ISyncRole
+  
+  def containsSyncer(value: Object): Boolean = {
+    syncer.foreach { s =>
+      if (+s == +value) {
+      //if (s.player.equals(value.player)) {
+        return true;
+      }
+    }
+    return false
+  }
+
+  def addSyncer(sync: ISyncRole): Unit = {
+    syncer += sync
+  }
+
+  /**
+    * Get the list of all sync roles.
+    */
+  def getSyncer(): Set[ISyncRole] = syncer
+
+  /**
+    * Clear the list of all sync roles.
+    */
+  def clearSyncer(): Unit = {
+    syncer = Set.empty
+  }
+
+  /**
+    * Get roles for integration classes. Should give less roles than getNextRole.
+    */
+  def getFirstIntegrationRole(classname: Object) : ISyncRole = {
+    val role: ISyncRole = this.getFirstRole(classname)
+    if (role != null)
+      this.addSyncer(role)
+    role
+  }
+
+  /**
+    * Get all roles for integration classes.
+    */
+  def getNextIntegrationRole(classname: Object) : ISyncRole = {
+    val role: ISyncRole = this.getNextRole(classname)
+    if (role != null)
+      this.addSyncer(role)
+    role
+  }
+
+  /**
+    * Get roles for all integration classes.
+    */
+  def isFirstIntegration(classname: Object): Boolean
+
+  /**
+    * Get boolean if next integration
+    */
+  def isNextIntegration(classname: Object): Boolean = {
+    isFirstIntegration(classname)
+  }
+
+  /**
+    * Create a new instance of this class.
+    */
+  def getNewInstance: ISyncCompartment
+
+  /**
+    * Get the name of this rule.
+    */
+  def getRuleName: String
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/ISynchronizationCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/ISynchronizationCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..367abacef32a54bb1a13688529a628f6f81a8dad
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/ISynchronizationCompartment.scala
@@ -0,0 +1,22 @@
+package org.rosi_project.model_management.sync
+
+import org.rosi_project.model_management.sync.roles.IRoleManager
+import scroll.internal.MultiCompartment
+
+/**
+  * Interface for the synchronization management compartment.
+  */
+trait ISynchronizationCompartment extends MultiCompartment {
+
+  protected var underConstruction: Boolean = false
+
+  /**
+    * Is currently in a process where new elements could be created.
+    */
+  def isUnderConstruction(): Boolean = underConstruction
+
+  /**
+    * Get a new RoleManager instance.
+    */
+  def createRoleManager(): IRoleManager
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/compartments/GeneralDestructor.scala b/src/main/scala/org/rosi_project/model_management/sync/compartments/GeneralDestructor.scala
new file mode 100644
index 0000000000000000000000000000000000000000..b9a0db9ee0ea770967801e613c4cdf0afd018d15
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/compartments/GeneralDestructor.scala
@@ -0,0 +1,73 @@
+package org.rosi_project.model_management.sync.compartments
+
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.sync.IDestructionCompartment
+import org.rosi_project.model_management.sync.roles.{ IDestructor, IRoleManager }
+
+import scala.collection.mutable.ListBuffer
+import org.rosi_project.model_management.core.ModelElementLists
+
+/**
+ * Calls the destruction method from all related RoleManagers and then deletes all roles from this player.
+ */
+object GeneralDestructor extends IDestructionCompartment {
+
+  override def getDestructorForClassName(classname: Object): IDestructor = new DeleteRole
+
+  override def getRuleName: String = "GeneralDestructor"
+  
+  class DeleteRole() extends IDestructor {
+
+    def deleteRoleFunction(): Unit = {
+      //remove this manager from all related ones
+      +this removeThisManager()
+      //clear list of related manager
+      +this clearRelatedManager()
+      //send notification about deletion
+      +this deletionNotification()
+
+      //delete all roles this element has
+      val player = this.player
+      if (player.isRight) {
+        val test: PlayerSync = player.right.get.asInstanceOf[PlayerSync]
+        ModelElementLists.removeElement(test)
+        val roles = test.roles()
+        roles.foreach { r =>
+          r.remove()
+        }
+      }
+    }
+  }
+
+  class DeleteRoleAndConnections() extends IDestructor {
+
+    def deleteRoleFunction(): Unit = {
+      //get the list of related manager
+      var relatedManagers: Set[IRoleManager] = (+this).getRelatedManager()
+      
+      //clear all lists from the related managers
+      (+this).clearListsOfRelatedManager()
+
+      //delete also all related elements
+      relatedManagers.foreach { m =>
+        (+m).deleteObjectFromSynchro()
+      }
+
+      //send notification about deletion
+      (+this).deletionNotification()
+
+      //clear now the related manager list
+      (+this).clearRelatedManager()
+      //delete all roles this element has
+      val player = this.player
+      if (player.isRight) {
+        val test: PlayerSync = player.right.get.asInstanceOf[PlayerSync]
+        ModelElementLists.removeElement(test)
+        val roles = test.roles()
+        roles.foreach { r =>
+          r.remove()
+        }
+      }
+    }
+  }
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/compartments/ModelElementsListGCExtension.scala b/src/main/scala/org/rosi_project/model_management/sync/compartments/ModelElementsListGCExtension.scala
new file mode 100644
index 0000000000000000000000000000000000000000..1bba7d49201855d065369e2bf1d2fbc3433e16ba
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/compartments/ModelElementsListGCExtension.scala
@@ -0,0 +1,58 @@
+package org.rosi_project.model_management.sync.compartments
+
+import org.rosi_project.model_management.core.ModelElementLists
+import org.rosi_project.model_management.sync.IExtenstionCompartment
+import org.rosi_project.model_management.sync.roles.IExtension
+import scroll.internal.errors.SCROLLErrors.TypeError
+
+/** Extension to delete instances which are removed from the synchronization context from the
+  * [[ModelElementLists]]. This extension therefore functions as some kind of garbage collector,
+  * hence the name.
+  *
+  * @author Rico Bergmann
+  */
+object ModelElementsListGCExtension extends IExtenstionCompartment {
+
+  /**
+    * Return a role instance that handles the extension process for the object.
+    */
+  override def getExtensionForClassName(classname: Object): IExtension = new GarbageCollector
+
+  /**
+    * Return a unique name that describes this extension.
+    */
+  override def getExtensionName(): String = "ModelElementsList GarbageCollector"
+
+  /** The actual extension.
+    */
+  class GarbageCollector extends IExtension {
+
+    /**
+      * Function to react on insertion behavior.
+      */
+    override def notifyInsertion(): Unit = {
+      ;
+    }
+
+    /**
+      * Function to react on deletion behavior.
+      */
+    override def notifyDeletion(): Unit = {      
+      val player: Either[TypeError, AnyRef] = this.player
+
+      player.right.foreach { obj =>
+        println(s"Removing $obj")
+        ModelElementLists.removeElement(obj)
+      }
+
+    }
+
+    /**
+      * Function to react on update behavior.
+      */
+    override def notifyUpdate(): Unit = {
+      ;
+    }
+  }
+
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/compartments/SuppressingConstructionCompartment.scala b/src/main/scala/org/rosi_project/model_management/sync/compartments/SuppressingConstructionCompartment.scala
new file mode 100644
index 0000000000000000000000000000000000000000..987002f50668715d97792f84bc04a3a80b65d562
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/compartments/SuppressingConstructionCompartment.scala
@@ -0,0 +1,30 @@
+package org.rosi_project.model_management.sync.compartments
+
+import org.rosi_project.model_management.core.{PlayerSync, SynchronizationCompartment}
+import org.rosi_project.model_management.sync.IConstructionCompartment
+import org.rosi_project.model_management.sync.roles.{IConstructor, IRoleManager}
+
+/** An [[IConstructionCompartment]] which will not create any related instances in other models
+  *
+  * @author Rico Bergmann
+  */
+object SuppressingConstructionCompartment extends IConstructionCompartment {
+
+  override def getConstructorForClassName(classname: Object): IConstructor = new Suppressor
+
+  override def getRuleName: String = "SuppressingConstructionCompartment"
+  
+  /** The constructor will only create the necessary `plays` relationships with the synchronization
+    * services
+    */
+  class Suppressor extends IConstructor {
+
+    override def construct(comp: PlayerSync, man: IRoleManager): Unit = {
+      // just set up the player
+      createContainerElement(start=true, con=true, comp, man)
+      makeCompleteConstructionProcess(containers)
+    }
+
+  }
+
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/helper/ConstructionContainer.scala b/src/main/scala/org/rosi_project/model_management/sync/helper/ConstructionContainer.scala
new file mode 100644
index 0000000000000000000000000000000000000000..55ebd19993d5e750b7fd730c1d5588c1761b9e0f
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/helper/ConstructionContainer.scala
@@ -0,0 +1,29 @@
+package org.rosi_project.model_management.sync.helper
+
+import org.rosi_project.model_management.sync.roles.IRoleManager
+import org.rosi_project.model_management.core.PlayerSync
+
+/**
+  * Helper class for all construction processes to manage standard work loads.
+  */
+class ConstructionContainer(val startElement: Boolean, val constructed: Boolean, val player: PlayerSync, val manager: IRoleManager) {
+  /**
+    * Returns true if it is the start construction element.
+    */
+  def isStartElement(): Boolean = startElement
+
+  /**
+    * Return true if it is new constructed.
+    */
+  def isConstructed(): Boolean = constructed
+
+  /**
+    * Get the PlayerSync instance of this element.
+    */
+  def getPlayerInstance(): PlayerSync = player
+
+  /**
+    * Get the RoleManager instance of this element
+    */
+  def getManagerInstance(): IRoleManager = manager
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/helper/IntegrationContainer.scala b/src/main/scala/org/rosi_project/model_management/sync/helper/IntegrationContainer.scala
new file mode 100644
index 0000000000000000000000000000000000000000..3237c18ee625f81f5ad8a830871bb5ab3a82c484
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/helper/IntegrationContainer.scala
@@ -0,0 +1,29 @@
+package org.rosi_project.model_management.sync.helper
+
+import org.rosi_project.model_management.sync.roles.IRoleManager
+import org.rosi_project.model_management.core.PlayerSync
+
+/**
+  * Helper class for all integration processes to manage standard work loads.
+  */
+class IntegrationContainer (val newPlayerInstance: PlayerSync, val oldPlayerInstance: PlayerSync) {
+  
+  var simpleRelatedManagerConnection: Boolean = true
+  var newManagerConnection: Boolean = true
+  var newManagerInstance: IRoleManager = null
+  
+  /**
+   * Get the new PlayerSync instance of this element.
+   */
+  def getNewPlayerInstance(): PlayerSync = newPlayerInstance
+  
+  /**
+   * Get the new RoleManager instance of this element
+   */
+  def getNewManagerInstance(): IRoleManager = newManagerInstance
+  
+  /**
+   * Get the old PlayerSync instance of this element.
+   */
+  def getOldPlayerInstance(): PlayerSync = oldPlayerInstance  
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sync/roles/IConstructor.scala b/src/main/scala/org/rosi_project/model_management/sync/roles/IConstructor.scala
new file mode 100644
index 0000000000000000000000000000000000000000..dcfacf14b08c5ab1ef88f8fea30729b9f2a0c615
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/roles/IConstructor.scala
@@ -0,0 +1,29 @@
+package org.rosi_project.model_management.sync.roles
+
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.sync.helper.ConstructionContainer
+
+/**
+  * Interface for the constructor roles.
+  */
+trait IConstructor {
+
+  /**
+    * Container list for the construction process.
+    */
+  protected var containers: Set[ConstructionContainer] = Set.empty
+
+  /**
+    * Create a container element with the incoming configuration.
+    */
+  protected def createContainerElement(start: Boolean, con: Boolean, play: PlayerSync, man: IRoleManager): Unit = {
+    if (play == null)
+      return
+    containers += new ConstructionContainer(start, con, play, man)
+  }
+
+  /**
+    * General construction function for external call.
+    */
+  def construct(comp: PlayerSync, man: IRoleManager): Unit
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/roles/IDestructor.scala b/src/main/scala/org/rosi_project/model_management/sync/roles/IDestructor.scala
new file mode 100644
index 0000000000000000000000000000000000000000..dd979c8b6567c578921d73cd4c48b6ea2e30ed8b
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/roles/IDestructor.scala
@@ -0,0 +1,12 @@
+package org.rosi_project.model_management.sync.roles
+
+/**
+  * Interface for the destructor roles.
+  */
+trait IDestructor {
+  
+  /**
+    * General destruction function for external call.
+    */
+  def deleteRoleFunction(): Unit
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/roles/IExtension.scala b/src/main/scala/org/rosi_project/model_management/sync/roles/IExtension.scala
new file mode 100644
index 0000000000000000000000000000000000000000..95363b572821c77015eeeb2b259dd02b23e461ac
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/roles/IExtension.scala
@@ -0,0 +1,22 @@
+package org.rosi_project.model_management.sync.roles
+
+/**
+  * Interface for the extension roles.
+  */
+trait IExtension {
+  
+  /**
+   * Function to react on insertion behavior.
+   */
+  def notifyInsertion(): Unit
+  
+  /**
+   * Function to react on deletion behavior.
+   */
+  def notifyDeletion(): Unit
+  
+  /**
+   * Function to react on update behavior.
+   */
+  def notifyUpdate(): Unit
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sync/roles/IIntegrator.scala b/src/main/scala/org/rosi_project/model_management/sync/roles/IIntegrator.scala
new file mode 100644
index 0000000000000000000000000000000000000000..33336c02a0847116fa16386734b58c23364ff44e
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/roles/IIntegrator.scala
@@ -0,0 +1,30 @@
+package org.rosi_project.model_management.sync.roles
+
+import org.rosi_project.model_management.sync.helper.IntegrationContainer
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.core.SynchronizationCompartment
+
+/**
+  * Interface for the integration roles.
+  */
+trait IIntegrator {
+
+  /**
+   * Container list for the integration process.
+   */
+  protected var containers: Set[IntegrationContainer] = Set.empty
+
+  /**
+   * Create a container element with the incoming configuration.
+   */
+  protected def createContainerElement(newPlayer: PlayerSync, oldPlayer: PlayerSync): Unit = {
+    if (newPlayer == null || oldPlayer == null)
+      return
+    containers += new IntegrationContainer(newPlayer, oldPlayer)
+  }
+  
+  /**
+   * General integration function for external call.
+   */
+  def integrate(comp: PlayerSync) : PlayerSync
+}
\ No newline at end of file
diff --git a/src/main/scala/org/rosi_project/model_management/sync/roles/IRoleManager.scala b/src/main/scala/org/rosi_project/model_management/sync/roles/IRoleManager.scala
new file mode 100644
index 0000000000000000000000000000000000000000..fa466ee7c73b030fbd9dbfaea7e58b53c49518d6
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/roles/IRoleManager.scala
@@ -0,0 +1,103 @@
+package org.rosi_project.model_management.sync.roles
+
+import org.rosi_project.model_management.core.PlayerSync
+
+import scala.collection.mutable.ListBuffer
+
+/**
+ * Interface for the manager roles.
+ */
+trait IRoleManager {
+
+  private var relatedManager: Set[IRoleManager] = Set.empty
+
+  /**
+   * Add a related manager to the list.
+   */
+  def addRelatedManager(related: IRoleManager): Unit = {
+    if (related == null || related.equals(this))
+      return
+    relatedManager += related
+  }
+
+  /**
+   * Get the list of related managers.
+   */
+  def getRelatedManager(): Set[IRoleManager] = relatedManager
+
+  /**
+   * Get this manager.
+   */
+  def getManager(): IRoleManager = this
+
+  /**
+   * Get this manager plus related manager.
+   */
+  def getAllManager(): Set[IRoleManager] = relatedManager + this
+
+  /**
+   * Remove a related manager from the list.
+   */
+  def removeRelatedManager(related: IRoleManager): Unit = {
+    if (related != null)
+      relatedManager -= related
+  }
+
+  /**
+   * Remove this manager from the lists of all related managers.
+   */
+  def removeThisManager(): Unit = {
+    relatedManager.foreach { m =>
+      m.removeRelatedManager(this)
+    }
+  }
+
+  /**
+   * Clear the lists of all related managers,
+   */
+  def clearListsOfRelatedManager(): Unit = {
+    relatedManager.foreach { m =>
+      m.clearRelatedManager()
+    }
+  }
+
+  /**
+   * Clear the list of this role manager.
+   */
+  def clearRelatedManager(): Unit = {
+    relatedManager = Set.empty
+  }
+
+  /**
+   * Create a relation between two IRoleManager instances.
+   */
+  def makeRelated(relate: IRoleManager): Unit = {
+    this.addRelatedManager(relate)
+    relate.addRelatedManager(this)
+  }
+
+  /**
+   * General manage function for external call.
+   */
+  def manage(value: PlayerSync): Unit
+
+  /**
+   * Function to manage the deletion.
+   */
+  def deleteManage(value: PlayerSync): Unit
+
+  /**
+   * Get related PlayerSync with the specific name.
+   */
+  def getRelatedClassFromName(name: String): PlayerSync
+
+  /**
+   * Create a relation between two IRoleManager and RoleManager of other PlayerSync instances.
+   */
+  def makePlayerSyncRelated(playerSync: PlayerSync): Unit
+
+  /**
+   * Print all Manager only for debug.
+   */
+  def printAllManager(): Unit
+}
diff --git a/src/main/scala/org/rosi_project/model_management/sync/roles/ISyncRole.scala b/src/main/scala/org/rosi_project/model_management/sync/roles/ISyncRole.scala
new file mode 100644
index 0000000000000000000000000000000000000000..7682043b230fb2bf9cb26f0efa101bc95d89e71f
--- /dev/null
+++ b/src/main/scala/org/rosi_project/model_management/sync/roles/ISyncRole.scala
@@ -0,0 +1,14 @@
+package org.rosi_project.model_management.sync.roles
+
+import org.rosi_project.model_management.sync.ISyncCompartment
+
+/**
+  * Interface for the synchronization roles.
+  */
+trait ISyncRole {
+  
+  /**
+    * Function to get the synchronization compartment from a role instance.
+    */
+  def getOuterCompartment: ISyncCompartment
+}
diff --git a/src/main/scala/query/AMLLanguageQuery.scala b/src/main/scala/query/AMLLanguageQuery.scala
new file mode 100644
index 0000000000000000000000000000000000000000..a13b9fb58753bb73668282ba75ab97b4aa802fdf
--- /dev/null
+++ b/src/main/scala/query/AMLLanguageQuery.scala
@@ -0,0 +1,446 @@
+package query
+
+import aml.SystemUnitClassInternalElementsInternalElement
+import aml.InternalElement
+import aml.SystemUnitClassAttributesAttribute
+import aml.CAEXObject
+import aml.Attribute
+import org.rosi_project.model_management.sum.query.IQueryViewCompartment
+import aml.InstanceHierarchyInternalElementsInternalElement
+import aml.InternalElementBaseSystemUnitSystemUnitClass
+import aml.HelperCAEXObject
+import aml.InstanceHierarchy
+import org.rosi_project.model_management.sum.query.CheckingOption
+import aml.SystemUnitClass
+
+class AMLLanguageQuery extends IQueryViewCompartment {
+
+  init("AMLLanguageQuery")
+
+  def createSystemUnitClass(): AMLLanguageQuery#SystemUnitClassRole = {
+    return new SystemUnitClassRole()
+  }
+
+  def createInternalElement(): AMLLanguageQuery#InternalElementRole = {
+    return new InternalElementRole()
+  }
+
+  def createCAEXObject(): AMLLanguageQuery#CAEXObjectRole = {
+    return new CAEXObjectRole()
+  }
+
+  def createAttribute(): AMLLanguageQuery#AttributeRole = {
+    return new AttributeRole()
+  }
+
+  def createInstanceHierarchy(): AMLLanguageQuery#InstanceHierarchyRole = {
+    return new InstanceHierarchyRole()
+  }
+
+  override def toString(): String = {
+    "AMLLanguageQuery:"
+  }
+
+  class SystemUnitClassRole extends CAEXObjectRole() {
+
+    private var internalElements: Set[AMLLanguageQuery#SystemUnitClassInternalElementsInternalElementRole] = Set.empty
+    private var attributes: Set[AMLLanguageQuery#SystemUnitClassAttributesAttributeRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new SystemUnitClass(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      internalElements.foreach(_.deleteElement())
+      attributes.foreach(_.deleteElement())
+    }
+
+    private[AMLLanguageQuery] def removeInternalElementsIntern(v: AMLLanguageQuery#SystemUnitClassInternalElementsInternalElementRole): Unit = {
+      internalElements -= v
+    }
+
+    private[AMLLanguageQuery] def setInternalElementsIntern(v: AMLLanguageQuery#SystemUnitClassInternalElementsInternalElementRole): Unit = {
+      internalElements += v
+    }
+
+    def getInternalElements(): Set[AMLLanguageQuery#InternalElementRole] = {
+      var vs: Set[AMLLanguageQuery#InternalElementRole] = Set.empty
+      internalElements.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasInternalElements(v: AMLLanguageQuery#InternalElementRole): Boolean = {
+      return getInternalElements.contains(v)
+    }
+
+    def addInternalElements(v: AMLLanguageQuery#InternalElementRole): Boolean = {
+      if (hasInternalElements(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new SystemUnitClassInternalElementsInternalElementRole(this, v)
+      return true
+    }
+
+    def removeInternalElements(v: AMLLanguageQuery#InternalElementRole): Boolean = {
+      if (!hasInternalElements(v)) return false
+      internalElements.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[AMLLanguageQuery] def removeAttributesIntern(v: AMLLanguageQuery#SystemUnitClassAttributesAttributeRole): Unit = {
+      attributes -= v
+    }
+
+    private[AMLLanguageQuery] def setAttributesIntern(v: AMLLanguageQuery#SystemUnitClassAttributesAttributeRole): Unit = {
+      attributes += v
+    }
+
+    def getAttributes(): Set[AMLLanguageQuery#AttributeRole] = {
+      var vs: Set[AMLLanguageQuery#AttributeRole] = Set.empty
+      attributes.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasAttributes(v: AMLLanguageQuery#AttributeRole): Boolean = {
+      return getAttributes.contains(v)
+    }
+
+    def addAttributes(v: AMLLanguageQuery#AttributeRole): Boolean = {
+      if (hasAttributes(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new SystemUnitClassAttributesAttributeRole(this, v)
+      return true
+    }
+
+    def removeAttributes(v: AMLLanguageQuery#AttributeRole): Boolean = {
+      if (!hasAttributes(v)) return false
+      attributes.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "SystemUnitClassRole:"
+    }
+
+  }
+
+  class AttributeRole extends CAEXObjectRole() {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Attribute(null, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getValueView(): String = {
+      +this getValue ()
+    }
+
+    def setValueView(value: String, check: CheckingOption.Value): Unit = {
+      +this setValue (value)
+      connected.addAttributeFilter("value", value.toString(), check)
+    }
+
+    override def toString(): String = {
+      "AttributeRole:"
+    }
+
+  }
+
+  class InstanceHierarchyRole extends CAEXObjectRole() {
+
+    private var internalElements: Set[AMLLanguageQuery#InstanceHierarchyInternalElementsInternalElementRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new InstanceHierarchy(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      internalElements.foreach(_.deleteElement())
+    }
+
+    private[AMLLanguageQuery] def removeInternalElementsIntern(v: AMLLanguageQuery#InstanceHierarchyInternalElementsInternalElementRole): Unit = {
+      internalElements -= v
+    }
+
+    private[AMLLanguageQuery] def setInternalElementsIntern(v: AMLLanguageQuery#InstanceHierarchyInternalElementsInternalElementRole): Unit = {
+      internalElements += v
+    }
+
+    def getInternalElements(): Set[AMLLanguageQuery#InternalElementRole] = {
+      var vs: Set[AMLLanguageQuery#InternalElementRole] = Set.empty
+      internalElements.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasInternalElements(v: AMLLanguageQuery#InternalElementRole): Boolean = {
+      return getInternalElements.contains(v)
+    }
+
+    def addInternalElements(v: AMLLanguageQuery#InternalElementRole): Boolean = {
+      if (hasInternalElements(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new InstanceHierarchyInternalElementsInternalElementRole(this, v)
+      return true
+    }
+
+    def removeInternalElements(v: AMLLanguageQuery#InternalElementRole): Boolean = {
+      if (!hasInternalElements(v)) return false
+      internalElements.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "InstanceHierarchyRole:"
+    }
+
+  }
+
+  class CAEXObjectRole extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new HelperCAEXObject(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    def getIdView(): String = {
+      +this getId ()
+    }
+
+    def setIdView(id: String, check: CheckingOption.Value): Unit = {
+      +this setId (id)
+      connected.addAttributeFilter("id", id.toString(), check)
+    }
+
+    override def toString(): String = {
+      "CAEXObjectRole:"
+    }
+
+  }
+
+  class InternalElementRole extends SystemUnitClassRole() {
+
+    private var baseSystemUnit: AMLLanguageQuery#InternalElementBaseSystemUnitSystemUnitClassRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new InternalElement(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (baseSystemUnit != null) baseSystemUnit.deleteElement()
+    }
+
+    private[AMLLanguageQuery] def removeBaseSystemUnitIntern(v: AMLLanguageQuery#InternalElementBaseSystemUnitSystemUnitClassRole): Unit = {
+      baseSystemUnit = null
+    }
+
+    private[AMLLanguageQuery] def setBaseSystemUnitIntern(v: AMLLanguageQuery#InternalElementBaseSystemUnitSystemUnitClassRole): Unit = {
+      baseSystemUnit = v
+    }
+
+    def getBaseSystemUnit(): AMLLanguageQuery#SystemUnitClassRole = {
+      return baseSystemUnit.getTarget()
+    }
+
+    def setBaseSystemUnit(v: AMLLanguageQuery#SystemUnitClassRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (baseSystemUnit != null) {
+        if (baseSystemUnit.getTarget() == v) return false
+        baseSystemUnit.deleteElement()
+      }
+      new InternalElementBaseSystemUnitSystemUnitClassRole(this, v)
+      return true
+    }
+
+    override def toString(): String = {
+      "InternalElementRole:"
+    }
+
+  }
+
+  class SystemUnitClassInternalElementsInternalElementRole(private val source: AMLLanguageQuery#SystemUnitClassRole, private val target: AMLLanguageQuery#InternalElementRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setInternalElementsIntern(this)
+      val sp: SystemUnitClass = source.player.right.get.asInstanceOf[SystemUnitClass]
+      val tp: InternalElement = target.player.right.get.asInstanceOf[InternalElement]
+      val v: SystemUnitClassInternalElementsInternalElement = new SystemUnitClassInternalElementsInternalElement(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeInternalElementsIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): AMLLanguageQuery#SystemUnitClassRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageQuery#InternalElementRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "SystemUnitClassInternalElementsInternalElementRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class SystemUnitClassAttributesAttributeRole(private val source: AMLLanguageQuery#SystemUnitClassRole, private val target: AMLLanguageQuery#AttributeRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setAttributesIntern(this)
+      val sp: SystemUnitClass = source.player.right.get.asInstanceOf[SystemUnitClass]
+      val tp: Attribute = target.player.right.get.asInstanceOf[Attribute]
+      val v: SystemUnitClassAttributesAttribute = new SystemUnitClassAttributesAttribute(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeAttributesIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): AMLLanguageQuery#SystemUnitClassRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageQuery#AttributeRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "SystemUnitClassAttributesAttributeRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class InstanceHierarchyInternalElementsInternalElementRole(private val source: AMLLanguageQuery#InstanceHierarchyRole, private val target: AMLLanguageQuery#InternalElementRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setInternalElementsIntern(this)
+      val sp: InstanceHierarchy = source.player.right.get.asInstanceOf[InstanceHierarchy]
+      val tp: InternalElement = target.player.right.get.asInstanceOf[InternalElement]
+      val v: InstanceHierarchyInternalElementsInternalElement = new InstanceHierarchyInternalElementsInternalElement(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeInternalElementsIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): AMLLanguageQuery#InstanceHierarchyRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageQuery#InternalElementRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "InstanceHierarchyInternalElementsInternalElementRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class InternalElementBaseSystemUnitSystemUnitClassRole(private val source: AMLLanguageQuery#InternalElementRole, private val target: AMLLanguageQuery#SystemUnitClassRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBaseSystemUnitIntern(this)
+      val sp: InternalElement = source.player.right.get.asInstanceOf[InternalElement]
+      val tp: SystemUnitClass = target.player.right.get.asInstanceOf[SystemUnitClass]
+      val v: InternalElementBaseSystemUnitSystemUnitClass = new InternalElementBaseSystemUnitSystemUnitClass(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBaseSystemUnitIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): AMLLanguageQuery#InternalElementRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageQuery#SystemUnitClassRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "InternalElementBaseSystemUnitSystemUnitClassRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/query/EclipseLibraryQuery.scala b/src/main/scala/query/EclipseLibraryQuery.scala
new file mode 100644
index 0000000000000000000000000000000000000000..344278b2a7816b09eac9556650287d0ade5b0392
--- /dev/null
+++ b/src/main/scala/query/EclipseLibraryQuery.scala
@@ -0,0 +1,1274 @@
+package query
+
+import elib.BookAuthorWriter
+import elib.BookCategory
+import elib.BookOnTapeReaderPerson
+import elib.Employee
+import elib.LibraryBranchesLibrary
+import elib.VideoCassette
+import elib.BookOnTapeAuthorWriter
+import elib.LibraryBooksBook
+import elib.LibraryBorrowersBorrower
+import elib.Borrower
+import elib.LibraryParentBranchLibrary
+import elib.Periodical
+import elib.Writer
+import elib.AudioVisualItem
+import org.rosi_project.model_management.sum.query.IQueryViewCompartment
+import elib.EmployeeManagerEmployee
+import elib.Person
+import java.util.Date
+import elib.BookOnTape
+import elib.VideoCassetteCastPerson
+import org.rosi_project.model_management.sum.query.CheckingOption
+import elib.Library
+import elib.Book
+import elib.LibraryWritersWriter
+import elib.LibraryEmployeesEmployee
+import elib.CirculatingItem
+import elib.Item
+import elib.LibraryStockItem
+
+class EclipseLibraryQuery extends IQueryViewCompartment {
+
+  init("EclipseLibraryQuery")
+
+  def createLibrary(): EclipseLibraryQuery#LibraryRole = {
+    return new LibraryRole()
+  }
+
+  def createPeriodical(): EclipseLibraryQuery#PeriodicalRole = {
+    return new PeriodicalRole()
+  }
+
+  def createPerson(): EclipseLibraryQuery#PersonRole = {
+    return new PersonRole()
+  }
+
+  def createBorrower(): EclipseLibraryQuery#BorrowerRole = {
+    return new BorrowerRole()
+  }
+
+  def createItem(): EclipseLibraryQuery#ItemRole = {
+    return new ItemRole()
+  }
+
+  def createAudioVisualItem(): EclipseLibraryQuery#AudioVisualItemRole = {
+    return new AudioVisualItemRole()
+  }
+
+  def createCirculatingItem(): EclipseLibraryQuery#CirculatingItemRole = {
+    return new CirculatingItemRole()
+  }
+
+  def createBookOnTape(): EclipseLibraryQuery#BookOnTapeRole = {
+    return new BookOnTapeRole()
+  }
+
+  def createVideoCassette(): EclipseLibraryQuery#VideoCassetteRole = {
+    return new VideoCassetteRole()
+  }
+
+  def createBook(): EclipseLibraryQuery#BookRole = {
+    return new BookRole()
+  }
+
+  def createWriter(): EclipseLibraryQuery#WriterRole = {
+    return new WriterRole()
+  }
+
+  def createEmployee(): EclipseLibraryQuery#EmployeeRole = {
+    return new EmployeeRole()
+  }
+
+  override def toString(): String = {
+    "EclipseLibraryQuery:"
+  }
+
+  class ItemRole extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Item(null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getPublicationDateView(): Date = {
+      +this getPublicationDate ()
+    }
+
+    def setPublicationDateView(publicationdate: Date, check: CheckingOption.Value): Unit = {
+      +this setPublicationDate (publicationdate)
+      connected.addAttributeFilter("publicationDate", publicationdate.toString(), check)
+    }
+
+    override def toString(): String = {
+      "ItemRole:"
+    }
+
+  }
+
+  class EmployeeRole extends PersonRole() {
+
+    private var manager: EclipseLibraryQuery#EmployeeManagerEmployeeRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Employee(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (manager != null) manager.deleteElement()
+    }
+
+    private[EclipseLibraryQuery] def removeManagerIntern(v: EclipseLibraryQuery#EmployeeManagerEmployeeRole): Unit = {
+      manager = null
+    }
+
+    private[EclipseLibraryQuery] def setManagerIntern(v: EclipseLibraryQuery#EmployeeManagerEmployeeRole): Unit = {
+      manager = v
+    }
+
+    def getManager(): EclipseLibraryQuery#EmployeeRole = {
+      return manager.getTarget()
+    }
+
+    def setManager(v: EclipseLibraryQuery#EmployeeRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (manager != null) {
+        if (manager.getTarget() == v) return false
+        manager.deleteElement()
+      }
+      new EmployeeManagerEmployeeRole(this, v)
+      return true
+    }
+
+    override def toString(): String = {
+      "EmployeeRole:"
+    }
+
+  }
+
+  class PeriodicalRole extends ItemRole() {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Periodical(0, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getIssuesPerYearView(): Int = {
+      +this getIssuesPerYear ()
+    }
+
+    def setIssuesPerYearView(issuesperyear: Int, check: CheckingOption.Value): Unit = {
+      +this setIssuesPerYear (issuesperyear)
+      connected.addAttributeFilter("issuesPerYear", issuesperyear.toString(), check)
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String, check: CheckingOption.Value): Unit = {
+      +this setTitle (title)
+      connected.addAttributeFilter("title", title.toString(), check)
+    }
+
+    override def toString(): String = {
+      "PeriodicalRole:"
+    }
+
+  }
+
+  class VideoCassetteRole extends AudioVisualItemRole() {
+
+    private var cast: Set[EclipseLibraryQuery#VideoCassetteCastPersonRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new VideoCassette(false, 0, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      cast.foreach(_.deleteElement())
+    }
+
+    private[EclipseLibraryQuery] def removeCastIntern(v: EclipseLibraryQuery#VideoCassetteCastPersonRole): Unit = {
+      cast -= v
+    }
+
+    private[EclipseLibraryQuery] def setCastIntern(v: EclipseLibraryQuery#VideoCassetteCastPersonRole): Unit = {
+      cast += v
+    }
+
+    def getCast(): Set[EclipseLibraryQuery#PersonRole] = {
+      var vs: Set[EclipseLibraryQuery#PersonRole] = Set.empty
+      cast.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasCast(v: EclipseLibraryQuery#PersonRole): Boolean = {
+      return getCast.contains(v)
+    }
+
+    def addCast(v: EclipseLibraryQuery#PersonRole): Boolean = {
+      if (hasCast(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new VideoCassetteCastPersonRole(this, v)
+      return true
+    }
+
+    def removeCast(v: EclipseLibraryQuery#PersonRole): Boolean = {
+      if (!hasCast(v)) return false
+      cast.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "VideoCassetteRole:"
+    }
+
+  }
+
+  class AudioVisualItemRole extends CirculatingItemRole() {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new AudioVisualItem(false, 0, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getDamagedView(): Boolean = {
+      +this getDamaged ()
+    }
+
+    def setDamagedView(damaged: Boolean, check: CheckingOption.Value): Unit = {
+      +this setDamaged (damaged)
+      connected.addAttributeFilter("damaged", damaged.toString(), check)
+    }
+
+    def getMinutesLengthView(): Int = {
+      +this getMinutesLength ()
+    }
+
+    def setMinutesLengthView(minuteslength: Int, check: CheckingOption.Value): Unit = {
+      +this setMinutesLength (minuteslength)
+      connected.addAttributeFilter("minutesLength", minuteslength.toString(), check)
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String, check: CheckingOption.Value): Unit = {
+      +this setTitle (title)
+      connected.addAttributeFilter("title", title.toString(), check)
+    }
+
+    override def toString(): String = {
+      "AudioVisualItemRole:"
+    }
+
+  }
+
+  class WriterRole extends PersonRole() {
+
+    private var books: Set[EclipseLibraryQuery#BookAuthorWriterRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Writer(null, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      books.foreach(_.deleteElement())
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    private[EclipseLibraryQuery] def removeBooksIntern(v: EclipseLibraryQuery#BookAuthorWriterRole): Unit = {
+      books -= v
+    }
+
+    private[EclipseLibraryQuery] def setBooksIntern(v: EclipseLibraryQuery#BookAuthorWriterRole): Unit = {
+      books += v
+    }
+
+    def getBooks(): Set[EclipseLibraryQuery#BookRole] = {
+      var vs: Set[EclipseLibraryQuery#BookRole] = Set.empty
+      books.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasBooks(v: EclipseLibraryQuery#BookRole): Boolean = {
+      return getBooks.contains(v)
+    }
+
+    def addBooks(v: EclipseLibraryQuery#BookRole): Boolean = {
+      if (hasBooks(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new BookAuthorWriterRole(v, this)
+      return true
+    }
+
+    def removeBooks(v: EclipseLibraryQuery#BookRole): Boolean = {
+      if (!hasBooks(v)) return false
+      books.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "WriterRole:"
+    }
+
+  }
+
+  class BookRole extends CirculatingItemRole() {
+
+    private var author: EclipseLibraryQuery#BookAuthorWriterRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Book(null, 0, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (author != null) author.deleteElement()
+    }
+
+    def getCategoryView(): BookCategory.Value = {
+      +this getCategory ()
+    }
+
+    def setCategoryView(category: BookCategory.Value, check: CheckingOption.Value): Unit = {
+      +this setCategory (category)
+      connected.addAttributeFilter("category", category.toString(), check)
+    }
+
+    def getPagesView(): Int = {
+      +this getPages ()
+    }
+
+    def setPagesView(pages: Int, check: CheckingOption.Value): Unit = {
+      +this setPages (pages)
+      connected.addAttributeFilter("pages", pages.toString(), check)
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String, check: CheckingOption.Value): Unit = {
+      +this setTitle (title)
+      connected.addAttributeFilter("title", title.toString(), check)
+    }
+
+    private[EclipseLibraryQuery] def removeAuthorIntern(v: EclipseLibraryQuery#BookAuthorWriterRole): Unit = {
+      author = null
+    }
+
+    private[EclipseLibraryQuery] def setAuthorIntern(v: EclipseLibraryQuery#BookAuthorWriterRole): Unit = {
+      author = v
+    }
+
+    def getAuthor(): EclipseLibraryQuery#WriterRole = {
+      return author.getTarget()
+    }
+
+    def setAuthor(v: EclipseLibraryQuery#WriterRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (author != null) {
+        if (author.getTarget() == v) return false
+        author.deleteElement()
+      }
+      new BookAuthorWriterRole(this, v)
+      return true
+    }
+
+    override def toString(): String = {
+      "BookRole:"
+    }
+
+  }
+
+  class LibraryRole extends AQueryViewRole {
+
+    private var employees: Set[EclipseLibraryQuery#LibraryEmployeesEmployeeRole] = Set.empty
+    private var parentBranch: EclipseLibraryQuery#LibraryParentBranchLibraryRole = null
+    private var writers: Set[EclipseLibraryQuery#LibraryWritersWriterRole] = Set.empty
+    private var borrowers: Set[EclipseLibraryQuery#LibraryBorrowersBorrowerRole] = Set.empty
+    private var stock: Set[EclipseLibraryQuery#LibraryStockItemRole] = Set.empty
+    private var branches: Set[EclipseLibraryQuery#LibraryBranchesLibraryRole] = Set.empty
+    private var books: Set[EclipseLibraryQuery#LibraryBooksBookRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Library(null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      employees.foreach(_.deleteElement())
+      if (parentBranch != null) parentBranch.deleteElement()
+      writers.foreach(_.deleteElement())
+      borrowers.foreach(_.deleteElement())
+      stock.foreach(_.deleteElement())
+      branches.foreach(_.deleteElement())
+      books.foreach(_.deleteElement())
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    private[EclipseLibraryQuery] def removeEmployeesIntern(v: EclipseLibraryQuery#LibraryEmployeesEmployeeRole): Unit = {
+      employees -= v
+    }
+
+    private[EclipseLibraryQuery] def setEmployeesIntern(v: EclipseLibraryQuery#LibraryEmployeesEmployeeRole): Unit = {
+      employees += v
+    }
+
+    def getEmployees(): Set[EclipseLibraryQuery#EmployeeRole] = {
+      var vs: Set[EclipseLibraryQuery#EmployeeRole] = Set.empty
+      employees.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasEmployees(v: EclipseLibraryQuery#EmployeeRole): Boolean = {
+      return getEmployees.contains(v)
+    }
+
+    def addEmployees(v: EclipseLibraryQuery#EmployeeRole): Boolean = {
+      if (hasEmployees(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryEmployeesEmployeeRole(this, v)
+      return true
+    }
+
+    def removeEmployees(v: EclipseLibraryQuery#EmployeeRole): Boolean = {
+      if (!hasEmployees(v)) return false
+      employees.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeParentBranchIntern(v: EclipseLibraryQuery#LibraryParentBranchLibraryRole): Unit = {
+      parentBranch = null
+    }
+
+    private[EclipseLibraryQuery] def setParentBranchIntern(v: EclipseLibraryQuery#LibraryParentBranchLibraryRole): Unit = {
+      parentBranch = v
+    }
+
+    def getParentBranch(): EclipseLibraryQuery#LibraryRole = {
+      return parentBranch.getTarget()
+    }
+
+    def setParentBranch(v: EclipseLibraryQuery#LibraryRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (parentBranch != null) {
+        if (parentBranch.getTarget() == v) return false
+        parentBranch.deleteElement()
+      }
+      new LibraryParentBranchLibraryRole(this, v)
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeWritersIntern(v: EclipseLibraryQuery#LibraryWritersWriterRole): Unit = {
+      writers -= v
+    }
+
+    private[EclipseLibraryQuery] def setWritersIntern(v: EclipseLibraryQuery#LibraryWritersWriterRole): Unit = {
+      writers += v
+    }
+
+    def getWriters(): Set[EclipseLibraryQuery#WriterRole] = {
+      var vs: Set[EclipseLibraryQuery#WriterRole] = Set.empty
+      writers.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasWriters(v: EclipseLibraryQuery#WriterRole): Boolean = {
+      return getWriters.contains(v)
+    }
+
+    def addWriters(v: EclipseLibraryQuery#WriterRole): Boolean = {
+      if (hasWriters(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryWritersWriterRole(this, v)
+      return true
+    }
+
+    def removeWriters(v: EclipseLibraryQuery#WriterRole): Boolean = {
+      if (!hasWriters(v)) return false
+      writers.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeBorrowersIntern(v: EclipseLibraryQuery#LibraryBorrowersBorrowerRole): Unit = {
+      borrowers -= v
+    }
+
+    private[EclipseLibraryQuery] def setBorrowersIntern(v: EclipseLibraryQuery#LibraryBorrowersBorrowerRole): Unit = {
+      borrowers += v
+    }
+
+    def getBorrowers(): Set[EclipseLibraryQuery#BorrowerRole] = {
+      var vs: Set[EclipseLibraryQuery#BorrowerRole] = Set.empty
+      borrowers.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasBorrowers(v: EclipseLibraryQuery#BorrowerRole): Boolean = {
+      return getBorrowers.contains(v)
+    }
+
+    def addBorrowers(v: EclipseLibraryQuery#BorrowerRole): Boolean = {
+      if (hasBorrowers(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryBorrowersBorrowerRole(this, v)
+      return true
+    }
+
+    def removeBorrowers(v: EclipseLibraryQuery#BorrowerRole): Boolean = {
+      if (!hasBorrowers(v)) return false
+      borrowers.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeStockIntern(v: EclipseLibraryQuery#LibraryStockItemRole): Unit = {
+      stock -= v
+    }
+
+    private[EclipseLibraryQuery] def setStockIntern(v: EclipseLibraryQuery#LibraryStockItemRole): Unit = {
+      stock += v
+    }
+
+    def getStock(): Set[EclipseLibraryQuery#ItemRole] = {
+      var vs: Set[EclipseLibraryQuery#ItemRole] = Set.empty
+      stock.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasStock(v: EclipseLibraryQuery#ItemRole): Boolean = {
+      return getStock.contains(v)
+    }
+
+    def addStock(v: EclipseLibraryQuery#ItemRole): Boolean = {
+      if (hasStock(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryStockItemRole(this, v)
+      return true
+    }
+
+    def removeStock(v: EclipseLibraryQuery#ItemRole): Boolean = {
+      if (!hasStock(v)) return false
+      stock.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeBranchesIntern(v: EclipseLibraryQuery#LibraryBranchesLibraryRole): Unit = {
+      branches -= v
+    }
+
+    private[EclipseLibraryQuery] def setBranchesIntern(v: EclipseLibraryQuery#LibraryBranchesLibraryRole): Unit = {
+      branches += v
+    }
+
+    def getBranches(): Set[EclipseLibraryQuery#LibraryRole] = {
+      var vs: Set[EclipseLibraryQuery#LibraryRole] = Set.empty
+      branches.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasBranches(v: EclipseLibraryQuery#LibraryRole): Boolean = {
+      return getBranches.contains(v)
+    }
+
+    def addBranches(v: EclipseLibraryQuery#LibraryRole): Boolean = {
+      if (hasBranches(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryBranchesLibraryRole(this, v)
+      return true
+    }
+
+    def removeBranches(v: EclipseLibraryQuery#LibraryRole): Boolean = {
+      if (!hasBranches(v)) return false
+      branches.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeBooksIntern(v: EclipseLibraryQuery#LibraryBooksBookRole): Unit = {
+      books -= v
+    }
+
+    private[EclipseLibraryQuery] def setBooksIntern(v: EclipseLibraryQuery#LibraryBooksBookRole): Unit = {
+      books += v
+    }
+
+    def getBooks(): Set[EclipseLibraryQuery#BookRole] = {
+      var vs: Set[EclipseLibraryQuery#BookRole] = Set.empty
+      books.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasBooks(v: EclipseLibraryQuery#BookRole): Boolean = {
+      return getBooks.contains(v)
+    }
+
+    def addBooks(v: EclipseLibraryQuery#BookRole): Boolean = {
+      if (hasBooks(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryBooksBookRole(this, v)
+      return true
+    }
+
+    def removeBooks(v: EclipseLibraryQuery#BookRole): Boolean = {
+      if (!hasBooks(v)) return false
+      books.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "LibraryRole:"
+    }
+
+  }
+
+  class BookOnTapeRole extends AudioVisualItemRole() {
+
+    private var author: EclipseLibraryQuery#BookOnTapeAuthorWriterRole = null
+    private var reader: EclipseLibraryQuery#BookOnTapeReaderPersonRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new BookOnTape(false, 0, null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (author != null) author.deleteElement()
+      if (reader != null) reader.deleteElement()
+    }
+
+    private[EclipseLibraryQuery] def removeAuthorIntern(v: EclipseLibraryQuery#BookOnTapeAuthorWriterRole): Unit = {
+      author = null
+    }
+
+    private[EclipseLibraryQuery] def setAuthorIntern(v: EclipseLibraryQuery#BookOnTapeAuthorWriterRole): Unit = {
+      author = v
+    }
+
+    def getAuthor(): EclipseLibraryQuery#WriterRole = {
+      return author.getTarget()
+    }
+
+    def setAuthor(v: EclipseLibraryQuery#WriterRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (author != null) {
+        if (author.getTarget() == v) return false
+        author.deleteElement()
+      }
+      new BookOnTapeAuthorWriterRole(this, v)
+      return true
+    }
+
+    private[EclipseLibraryQuery] def removeReaderIntern(v: EclipseLibraryQuery#BookOnTapeReaderPersonRole): Unit = {
+      reader = null
+    }
+
+    private[EclipseLibraryQuery] def setReaderIntern(v: EclipseLibraryQuery#BookOnTapeReaderPersonRole): Unit = {
+      reader = v
+    }
+
+    def getReader(): EclipseLibraryQuery#PersonRole = {
+      return reader.getTarget()
+    }
+
+    def setReader(v: EclipseLibraryQuery#PersonRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (reader != null) {
+        if (reader.getTarget() == v) return false
+        reader.deleteElement()
+      }
+      new BookOnTapeReaderPersonRole(this, v)
+      return true
+    }
+
+    override def toString(): String = {
+      "BookOnTapeRole:"
+    }
+
+  }
+
+  class CirculatingItemRole extends ItemRole() {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new CirculatingItem(null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "CirculatingItemRole:"
+    }
+
+  }
+
+  class BorrowerRole extends PersonRole() {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Borrower(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "BorrowerRole:"
+    }
+
+  }
+
+  class PersonRole extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Person(null, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getLastNameView(): String = {
+      +this getLastName ()
+    }
+
+    def setLastNameView(lastname: String, check: CheckingOption.Value): Unit = {
+      +this setLastName (lastname)
+      connected.addAttributeFilter("lastName", lastname.toString(), check)
+    }
+
+    def getFirstNameView(): String = {
+      +this getFirstName ()
+    }
+
+    def setFirstNameView(firstname: String, check: CheckingOption.Value): Unit = {
+      +this setFirstName (firstname)
+      connected.addAttributeFilter("firstName", firstname.toString(), check)
+    }
+
+    override def toString(): String = {
+      "PersonRole:"
+    }
+
+  }
+
+  class LibraryEmployeesEmployeeRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#EmployeeRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setEmployeesIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Employee = target.player.right.get.asInstanceOf[Employee]
+      val v: LibraryEmployeesEmployee = new LibraryEmployeesEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeEmployeesIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#EmployeeRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryEmployeesEmployeeRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class LibraryParentBranchLibraryRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#LibraryRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setParentBranchIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Library = target.player.right.get.asInstanceOf[Library]
+      val v: LibraryParentBranchLibrary = new LibraryParentBranchLibrary(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeParentBranchIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#LibraryRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryParentBranchLibraryRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class LibraryWritersWriterRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#WriterRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setWritersIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Writer = target.player.right.get.asInstanceOf[Writer]
+      val v: LibraryWritersWriter = new LibraryWritersWriter(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeWritersIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#WriterRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryWritersWriterRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class BookOnTapeAuthorWriterRole(private val source: EclipseLibraryQuery#BookOnTapeRole, private val target: EclipseLibraryQuery#WriterRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setAuthorIntern(this)
+      val sp: BookOnTape = source.player.right.get.asInstanceOf[BookOnTape]
+      val tp: Writer = target.player.right.get.asInstanceOf[Writer]
+      val v: BookOnTapeAuthorWriter = new BookOnTapeAuthorWriter(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeAuthorIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#BookOnTapeRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#WriterRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "BookOnTapeAuthorWriterRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class BookOnTapeReaderPersonRole(private val source: EclipseLibraryQuery#BookOnTapeRole, private val target: EclipseLibraryQuery#PersonRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setReaderIntern(this)
+      val sp: BookOnTape = source.player.right.get.asInstanceOf[BookOnTape]
+      val tp: Person = target.player.right.get.asInstanceOf[Person]
+      val v: BookOnTapeReaderPerson = new BookOnTapeReaderPerson(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeReaderIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#BookOnTapeRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#PersonRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "BookOnTapeReaderPersonRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class LibraryBorrowersBorrowerRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#BorrowerRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBorrowersIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Borrower = target.player.right.get.asInstanceOf[Borrower]
+      val v: LibraryBorrowersBorrower = new LibraryBorrowersBorrower(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBorrowersIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#BorrowerRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryBorrowersBorrowerRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class LibraryStockItemRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#ItemRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setStockIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Item = target.player.right.get.asInstanceOf[Item]
+      val v: LibraryStockItem = new LibraryStockItem(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeStockIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#ItemRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryStockItemRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class BookAuthorWriterRole(private val source: EclipseLibraryQuery#BookRole, private val target: EclipseLibraryQuery#WriterRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setBooksIntern(this)
+      source.setAuthorIntern(this)
+      val sp: Book = source.player.right.get.asInstanceOf[Book]
+      val tp: Writer = target.player.right.get.asInstanceOf[Writer]
+      val v: BookAuthorWriter = new BookAuthorWriter(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeAuthorIntern(this)
+      target.removeBooksIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#BookRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#WriterRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "BookAuthorWriterRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class LibraryBranchesLibraryRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#LibraryRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBranchesIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Library = target.player.right.get.asInstanceOf[Library]
+      val v: LibraryBranchesLibrary = new LibraryBranchesLibrary(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBranchesIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#LibraryRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryBranchesLibraryRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class VideoCassetteCastPersonRole(private val source: EclipseLibraryQuery#VideoCassetteRole, private val target: EclipseLibraryQuery#PersonRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setCastIntern(this)
+      val sp: VideoCassette = source.player.right.get.asInstanceOf[VideoCassette]
+      val tp: Person = target.player.right.get.asInstanceOf[Person]
+      val v: VideoCassetteCastPerson = new VideoCassetteCastPerson(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeCastIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#VideoCassetteRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#PersonRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "VideoCassetteCastPersonRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class EmployeeManagerEmployeeRole(private val source: EclipseLibraryQuery#EmployeeRole, private val target: EclipseLibraryQuery#EmployeeRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setManagerIntern(this)
+      val sp: Employee = source.player.right.get.asInstanceOf[Employee]
+      val tp: Employee = target.player.right.get.asInstanceOf[Employee]
+      val v: EmployeeManagerEmployee = new EmployeeManagerEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeManagerIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#EmployeeRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#EmployeeRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "EmployeeManagerEmployeeRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class LibraryBooksBookRole(private val source: EclipseLibraryQuery#LibraryRole, private val target: EclipseLibraryQuery#BookRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBooksIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Book = target.player.right.get.asInstanceOf[Book]
+      val v: LibraryBooksBook = new LibraryBooksBook(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBooksIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): EclipseLibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryQuery#BookRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryBooksBookRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/query/IMDBdatabaseQuery.scala b/src/main/scala/query/IMDBdatabaseQuery.scala
new file mode 100644
index 0000000000000000000000000000000000000000..12c15eeb6de771f2d6aa8171d3ad013c55e75951
--- /dev/null
+++ b/src/main/scala/query/IMDBdatabaseQuery.scala
@@ -0,0 +1,1028 @@
+package query
+
+import imdbdatabase.User
+import imdbdatabase.IMDBFilmsFilm
+import imdbdatabase.FilmFiguresFigure
+import imdbdatabase.VoteFilmFilm
+import imdbdatabase.Film
+import imdbdatabase.IMDBVotesVote
+import imdbdatabase.VoteUserUser
+import imdbdatabase.FigurePlayedByActor
+import imdbdatabase.Person
+import org.rosi_project.model_management.sum.query.IQueryViewCompartment
+import imdbdatabase.IMDB
+import imdbdatabase.Figure
+import imdbdatabase.Actor
+import org.rosi_project.model_management.sum.query.CheckingOption
+import imdbdatabase.Vote
+import imdbdatabase.IMDBUsersUser
+import imdbdatabase.IMDBActorsActor
+
+class IMDBdatabaseQuery extends IQueryViewCompartment {
+
+  init("IMDBdatabaseQuery")
+
+  def createFigure(): IMDBdatabaseQuery#FigureRole = {
+    return new FigureRole()
+  }
+
+  def createActor(): IMDBdatabaseQuery#ActorRole = {
+    return new ActorRole()
+  }
+
+  def createPerson(): IMDBdatabaseQuery#PersonRole = {
+    return new PersonRole()
+  }
+
+  def createUser(): IMDBdatabaseQuery#UserRole = {
+    return new UserRole()
+  }
+
+  def createVote(): IMDBdatabaseQuery#VoteRole = {
+    return new VoteRole()
+  }
+
+  def createIMDB(): IMDBdatabaseQuery#IMDBRole = {
+    return new IMDBRole()
+  }
+
+  def createFilm(): IMDBdatabaseQuery#FilmRole = {
+    return new FilmRole()
+  }
+
+  override def toString(): String = {
+    "IMDBdatabaseQuery:"
+  }
+
+  class IMDBRole extends AQueryViewRole {
+
+    private var users: Set[IMDBdatabaseQuery#IMDBUsersUserRole] = Set.empty
+    private var votes: Set[IMDBdatabaseQuery#IMDBVotesVoteRole] = Set.empty
+    private var actors: Set[IMDBdatabaseQuery#IMDBActorsActorRole] = Set.empty
+    private var films: Set[IMDBdatabaseQuery#IMDBFilmsFilmRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new IMDB()
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      users.foreach(_.deleteElement())
+      votes.foreach(_.deleteElement())
+      actors.foreach(_.deleteElement())
+      films.foreach(_.deleteElement())
+    }
+
+    private[IMDBdatabaseQuery] def removeUsersIntern(v: IMDBdatabaseQuery#IMDBUsersUserRole): Unit = {
+      users -= v
+    }
+
+    private[IMDBdatabaseQuery] def setUsersIntern(v: IMDBdatabaseQuery#IMDBUsersUserRole): Unit = {
+      users += v
+    }
+
+    def getUsers(): Set[IMDBdatabaseQuery#UserRole] = {
+      var vs: Set[IMDBdatabaseQuery#UserRole] = Set.empty
+      users.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasUsers(v: IMDBdatabaseQuery#UserRole): Boolean = {
+      return getUsers.contains(v)
+    }
+
+    def addUsers(v: IMDBdatabaseQuery#UserRole): Boolean = {
+      if (hasUsers(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new IMDBUsersUserRole(this, v)
+      return true
+    }
+
+    def removeUsers(v: IMDBdatabaseQuery#UserRole): Boolean = {
+      if (!hasUsers(v)) return false
+      users.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeVotesIntern(v: IMDBdatabaseQuery#IMDBVotesVoteRole): Unit = {
+      votes -= v
+    }
+
+    private[IMDBdatabaseQuery] def setVotesIntern(v: IMDBdatabaseQuery#IMDBVotesVoteRole): Unit = {
+      votes += v
+    }
+
+    def getVotes(): Set[IMDBdatabaseQuery#VoteRole] = {
+      var vs: Set[IMDBdatabaseQuery#VoteRole] = Set.empty
+      votes.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasVotes(v: IMDBdatabaseQuery#VoteRole): Boolean = {
+      return getVotes.contains(v)
+    }
+
+    def addVotes(v: IMDBdatabaseQuery#VoteRole): Boolean = {
+      if (hasVotes(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new IMDBVotesVoteRole(this, v)
+      return true
+    }
+
+    def removeVotes(v: IMDBdatabaseQuery#VoteRole): Boolean = {
+      if (!hasVotes(v)) return false
+      votes.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeActorsIntern(v: IMDBdatabaseQuery#IMDBActorsActorRole): Unit = {
+      actors -= v
+    }
+
+    private[IMDBdatabaseQuery] def setActorsIntern(v: IMDBdatabaseQuery#IMDBActorsActorRole): Unit = {
+      actors += v
+    }
+
+    def getActors(): Set[IMDBdatabaseQuery#ActorRole] = {
+      var vs: Set[IMDBdatabaseQuery#ActorRole] = Set.empty
+      actors.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasActors(v: IMDBdatabaseQuery#ActorRole): Boolean = {
+      return getActors.contains(v)
+    }
+
+    def addActors(v: IMDBdatabaseQuery#ActorRole): Boolean = {
+      if (hasActors(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new IMDBActorsActorRole(this, v)
+      return true
+    }
+
+    def removeActors(v: IMDBdatabaseQuery#ActorRole): Boolean = {
+      if (!hasActors(v)) return false
+      actors.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeFilmsIntern(v: IMDBdatabaseQuery#IMDBFilmsFilmRole): Unit = {
+      films -= v
+    }
+
+    private[IMDBdatabaseQuery] def setFilmsIntern(v: IMDBdatabaseQuery#IMDBFilmsFilmRole): Unit = {
+      films += v
+    }
+
+    def getFilms(): Set[IMDBdatabaseQuery#FilmRole] = {
+      var vs: Set[IMDBdatabaseQuery#FilmRole] = Set.empty
+      films.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasFilms(v: IMDBdatabaseQuery#FilmRole): Boolean = {
+      return getFilms.contains(v)
+    }
+
+    def addFilms(v: IMDBdatabaseQuery#FilmRole): Boolean = {
+      if (hasFilms(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new IMDBFilmsFilmRole(this, v)
+      return true
+    }
+
+    def removeFilms(v: IMDBdatabaseQuery#FilmRole): Boolean = {
+      if (!hasFilms(v)) return false
+      films.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "IMDBRole:"
+    }
+
+  }
+
+  class FilmRole extends AQueryViewRole {
+
+    private var library: IMDBdatabaseQuery#IMDBFilmsFilmRole = null
+    private var votes: Set[IMDBdatabaseQuery#VoteFilmFilmRole] = Set.empty
+    private var figures: Set[IMDBdatabaseQuery#FilmFiguresFigureRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Film(0, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (library != null) library.deleteElement()
+      votes.foreach(_.deleteElement())
+      figures.foreach(_.deleteElement())
+    }
+
+    def getYearView(): Int = {
+      +this getYear ()
+    }
+
+    def setYearView(year: Int, check: CheckingOption.Value): Unit = {
+      +this setYear (year)
+      connected.addAttributeFilter("year", year.toString(), check)
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String, check: CheckingOption.Value): Unit = {
+      +this setTitle (title)
+      connected.addAttributeFilter("title", title.toString(), check)
+    }
+
+    private[IMDBdatabaseQuery] def removeLibraryIntern(v: IMDBdatabaseQuery#IMDBFilmsFilmRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseQuery] def setLibraryIntern(v: IMDBdatabaseQuery#IMDBFilmsFilmRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseQuery#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseQuery#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBFilmsFilmRole(v, this)
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeVotesIntern(v: IMDBdatabaseQuery#VoteFilmFilmRole): Unit = {
+      votes -= v
+    }
+
+    private[IMDBdatabaseQuery] def setVotesIntern(v: IMDBdatabaseQuery#VoteFilmFilmRole): Unit = {
+      votes += v
+    }
+
+    def getVotes(): Set[IMDBdatabaseQuery#VoteRole] = {
+      var vs: Set[IMDBdatabaseQuery#VoteRole] = Set.empty
+      votes.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasVotes(v: IMDBdatabaseQuery#VoteRole): Boolean = {
+      return getVotes.contains(v)
+    }
+
+    def addVotes(v: IMDBdatabaseQuery#VoteRole): Boolean = {
+      if (hasVotes(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new VoteFilmFilmRole(v, this)
+      return true
+    }
+
+    def removeVotes(v: IMDBdatabaseQuery#VoteRole): Boolean = {
+      if (!hasVotes(v)) return false
+      votes.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeFiguresIntern(v: IMDBdatabaseQuery#FilmFiguresFigureRole): Unit = {
+      figures -= v
+    }
+
+    private[IMDBdatabaseQuery] def setFiguresIntern(v: IMDBdatabaseQuery#FilmFiguresFigureRole): Unit = {
+      figures += v
+    }
+
+    def getFigures(): Set[IMDBdatabaseQuery#FigureRole] = {
+      var vs: Set[IMDBdatabaseQuery#FigureRole] = Set.empty
+      figures.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasFigures(v: IMDBdatabaseQuery#FigureRole): Boolean = {
+      return getFigures.contains(v)
+    }
+
+    def addFigures(v: IMDBdatabaseQuery#FigureRole): Boolean = {
+      if (hasFigures(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new FilmFiguresFigureRole(this, v)
+      return true
+    }
+
+    def removeFigures(v: IMDBdatabaseQuery#FigureRole): Boolean = {
+      if (!hasFigures(v)) return false
+      figures.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "FilmRole:"
+    }
+
+  }
+
+  class VoteRole extends AQueryViewRole {
+
+    private var user: IMDBdatabaseQuery#VoteUserUserRole = null
+    private var library: IMDBdatabaseQuery#IMDBVotesVoteRole = null
+    private var film: IMDBdatabaseQuery#VoteFilmFilmRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Vote(0)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (user != null) user.deleteElement()
+      if (library != null) library.deleteElement()
+      if (film != null) film.deleteElement()
+    }
+
+    def getScoreView(): Int = {
+      +this getScore ()
+    }
+
+    def setScoreView(score: Int, check: CheckingOption.Value): Unit = {
+      +this setScore (score)
+      connected.addAttributeFilter("score", score.toString(), check)
+    }
+
+    private[IMDBdatabaseQuery] def removeUserIntern(v: IMDBdatabaseQuery#VoteUserUserRole): Unit = {
+      user = null
+    }
+
+    private[IMDBdatabaseQuery] def setUserIntern(v: IMDBdatabaseQuery#VoteUserUserRole): Unit = {
+      user = v
+    }
+
+    def getUser(): IMDBdatabaseQuery#UserRole = {
+      return user.getTarget()
+    }
+
+    def setUser(v: IMDBdatabaseQuery#UserRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (user != null) {
+        if (user.getTarget() == v) return false
+        user.deleteElement()
+      }
+      new VoteUserUserRole(this, v)
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeLibraryIntern(v: IMDBdatabaseQuery#IMDBVotesVoteRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseQuery] def setLibraryIntern(v: IMDBdatabaseQuery#IMDBVotesVoteRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseQuery#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseQuery#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBVotesVoteRole(v, this)
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeFilmIntern(v: IMDBdatabaseQuery#VoteFilmFilmRole): Unit = {
+      film = null
+    }
+
+    private[IMDBdatabaseQuery] def setFilmIntern(v: IMDBdatabaseQuery#VoteFilmFilmRole): Unit = {
+      film = v
+    }
+
+    def getFilm(): IMDBdatabaseQuery#FilmRole = {
+      return film.getTarget()
+    }
+
+    def setFilm(v: IMDBdatabaseQuery#FilmRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (film != null) {
+        if (film.getTarget() == v) return false
+        film.deleteElement()
+      }
+      new VoteFilmFilmRole(this, v)
+      return true
+    }
+
+    override def toString(): String = {
+      "VoteRole:"
+    }
+
+  }
+
+  class ActorRole extends PersonRole() {
+
+    private var plays: Set[IMDBdatabaseQuery#FigurePlayedByActorRole] = Set.empty
+    private var library: IMDBdatabaseQuery#IMDBActorsActorRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Actor(0, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      plays.foreach(_.deleteElement())
+      if (library != null) library.deleteElement()
+    }
+
+    private[IMDBdatabaseQuery] def removePlaysIntern(v: IMDBdatabaseQuery#FigurePlayedByActorRole): Unit = {
+      plays -= v
+    }
+
+    private[IMDBdatabaseQuery] def setPlaysIntern(v: IMDBdatabaseQuery#FigurePlayedByActorRole): Unit = {
+      plays += v
+    }
+
+    def getPlays(): Set[IMDBdatabaseQuery#FigureRole] = {
+      var vs: Set[IMDBdatabaseQuery#FigureRole] = Set.empty
+      plays.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasPlays(v: IMDBdatabaseQuery#FigureRole): Boolean = {
+      return getPlays.contains(v)
+    }
+
+    def addPlays(v: IMDBdatabaseQuery#FigureRole): Boolean = {
+      if (hasPlays(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new FigurePlayedByActorRole(v, this)
+      return true
+    }
+
+    def removePlays(v: IMDBdatabaseQuery#FigureRole): Boolean = {
+      if (!hasPlays(v)) return false
+      plays.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeLibraryIntern(v: IMDBdatabaseQuery#IMDBActorsActorRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseQuery] def setLibraryIntern(v: IMDBdatabaseQuery#IMDBActorsActorRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseQuery#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseQuery#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBActorsActorRole(v, this)
+      return true
+    }
+
+    override def toString(): String = {
+      "ActorRole:"
+    }
+
+  }
+
+  class PersonRole extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Person(0, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getDobView(): Double = {
+      +this getDob ()
+    }
+
+    def setDobView(dob: Double, check: CheckingOption.Value): Unit = {
+      +this setDob (dob)
+      connected.addAttributeFilter("dob", dob.toString(), check)
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    override def toString(): String = {
+      "PersonRole:"
+    }
+
+  }
+
+  class FigureRole extends AQueryViewRole {
+
+    private var playedBy: Set[IMDBdatabaseQuery#FigurePlayedByActorRole] = Set.empty
+    private var film: IMDBdatabaseQuery#FilmFiguresFigureRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Figure(null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      playedBy.foreach(_.deleteElement())
+      if (film != null) film.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    private[IMDBdatabaseQuery] def removePlayedByIntern(v: IMDBdatabaseQuery#FigurePlayedByActorRole): Unit = {
+      playedBy -= v
+    }
+
+    private[IMDBdatabaseQuery] def setPlayedByIntern(v: IMDBdatabaseQuery#FigurePlayedByActorRole): Unit = {
+      playedBy += v
+    }
+
+    def getPlayedBy(): Set[IMDBdatabaseQuery#ActorRole] = {
+      var vs: Set[IMDBdatabaseQuery#ActorRole] = Set.empty
+      playedBy.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasPlayedBy(v: IMDBdatabaseQuery#ActorRole): Boolean = {
+      return getPlayedBy.contains(v)
+    }
+
+    def addPlayedBy(v: IMDBdatabaseQuery#ActorRole): Boolean = {
+      if (hasPlayedBy(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new FigurePlayedByActorRole(this, v)
+      return true
+    }
+
+    def removePlayedBy(v: IMDBdatabaseQuery#ActorRole): Boolean = {
+      if (!hasPlayedBy(v)) return false
+      playedBy.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseQuery] def removeFilmIntern(v: IMDBdatabaseQuery#FilmFiguresFigureRole): Unit = {
+      film = null
+    }
+
+    private[IMDBdatabaseQuery] def setFilmIntern(v: IMDBdatabaseQuery#FilmFiguresFigureRole): Unit = {
+      film = v
+    }
+
+    def getFilm(): IMDBdatabaseQuery#FilmRole = {
+      return film.getSource()
+    }
+
+    def setFilm(v: IMDBdatabaseQuery#FilmRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (film != null) {
+        if (film.getSource() == v) return false
+        film.deleteElement()
+      }
+      new FilmFiguresFigureRole(v, this)
+      return true
+    }
+
+    override def toString(): String = {
+      "FigureRole:"
+    }
+
+  }
+
+  class UserRole extends PersonRole() {
+
+    private var library: IMDBdatabaseQuery#IMDBUsersUserRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new User(null, null, 0, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (library != null) library.deleteElement()
+    }
+
+    def getEmailView(): String = {
+      +this getEmail ()
+    }
+
+    def setEmailView(email: String, check: CheckingOption.Value): Unit = {
+      +this setEmail (email)
+      connected.addAttributeFilter("email", email.toString(), check)
+    }
+
+    def getUserNameView(): String = {
+      +this getUserName ()
+    }
+
+    def setUserNameView(username: String, check: CheckingOption.Value): Unit = {
+      +this setUserName (username)
+      connected.addAttributeFilter("userName", username.toString(), check)
+    }
+
+    private[IMDBdatabaseQuery] def removeLibraryIntern(v: IMDBdatabaseQuery#IMDBUsersUserRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseQuery] def setLibraryIntern(v: IMDBdatabaseQuery#IMDBUsersUserRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseQuery#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseQuery#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBUsersUserRole(v, this)
+      return true
+    }
+
+    override def toString(): String = {
+      "UserRole:"
+    }
+
+  }
+
+  class FigurePlayedByActorRole(private val source: IMDBdatabaseQuery#FigureRole, private val target: IMDBdatabaseQuery#ActorRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setPlaysIntern(this)
+      source.setPlayedByIntern(this)
+      val sp: Figure = source.player.right.get.asInstanceOf[Figure]
+      val tp: Actor = target.player.right.get.asInstanceOf[Actor]
+      val v: FigurePlayedByActor = new FigurePlayedByActor(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removePlayedByIntern(this)
+      target.removePlaysIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#FigureRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#ActorRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "FigurePlayedByActorRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class VoteUserUserRole(private val source: IMDBdatabaseQuery#VoteRole, private val target: IMDBdatabaseQuery#UserRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setUserIntern(this)
+      val sp: Vote = source.player.right.get.asInstanceOf[Vote]
+      val tp: User = target.player.right.get.asInstanceOf[User]
+      val v: VoteUserUser = new VoteUserUser(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeUserIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#VoteRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#UserRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "VoteUserUserRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class IMDBUsersUserRole(private val source: IMDBdatabaseQuery#IMDBRole, private val target: IMDBdatabaseQuery#UserRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setUsersIntern(this)
+      val sp: IMDB = source.player.right.get.asInstanceOf[IMDB]
+      val tp: User = target.player.right.get.asInstanceOf[User]
+      val v: IMDBUsersUser = new IMDBUsersUser(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeUsersIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#UserRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "IMDBUsersUserRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class IMDBVotesVoteRole(private val source: IMDBdatabaseQuery#IMDBRole, private val target: IMDBdatabaseQuery#VoteRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setVotesIntern(this)
+      val sp: IMDB = source.player.right.get.asInstanceOf[IMDB]
+      val tp: Vote = target.player.right.get.asInstanceOf[Vote]
+      val v: IMDBVotesVote = new IMDBVotesVote(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeVotesIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#VoteRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "IMDBVotesVoteRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class IMDBActorsActorRole(private val source: IMDBdatabaseQuery#IMDBRole, private val target: IMDBdatabaseQuery#ActorRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setActorsIntern(this)
+      val sp: IMDB = source.player.right.get.asInstanceOf[IMDB]
+      val tp: Actor = target.player.right.get.asInstanceOf[Actor]
+      val v: IMDBActorsActor = new IMDBActorsActor(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeActorsIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#ActorRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "IMDBActorsActorRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class IMDBFilmsFilmRole(private val source: IMDBdatabaseQuery#IMDBRole, private val target: IMDBdatabaseQuery#FilmRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setFilmsIntern(this)
+      val sp: IMDB = source.player.right.get.asInstanceOf[IMDB]
+      val tp: Film = target.player.right.get.asInstanceOf[Film]
+      val v: IMDBFilmsFilm = new IMDBFilmsFilm(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeFilmsIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#FilmRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "IMDBFilmsFilmRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class VoteFilmFilmRole(private val source: IMDBdatabaseQuery#VoteRole, private val target: IMDBdatabaseQuery#FilmRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setVotesIntern(this)
+      source.setFilmIntern(this)
+      val sp: Vote = source.player.right.get.asInstanceOf[Vote]
+      val tp: Film = target.player.right.get.asInstanceOf[Film]
+      val v: VoteFilmFilm = new VoteFilmFilm(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeFilmIntern(this)
+      target.removeVotesIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#VoteRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#FilmRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "VoteFilmFilmRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class FilmFiguresFigureRole(private val source: IMDBdatabaseQuery#FilmRole, private val target: IMDBdatabaseQuery#FigureRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setFilmIntern(this)
+      source.setFiguresIntern(this)
+      val sp: Film = source.player.right.get.asInstanceOf[Film]
+      val tp: Figure = target.player.right.get.asInstanceOf[Figure]
+      val v: FilmFiguresFigure = new FilmFiguresFigure(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeFiguresIntern(this)
+      target.removeFilmIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): IMDBdatabaseQuery#FilmRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseQuery#FigureRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "FilmFiguresFigureRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/query/LibraryQuery.scala b/src/main/scala/query/LibraryQuery.scala
new file mode 100644
index 0000000000000000000000000000000000000000..809b0f1b1bba06a2c67bc61e9bbade9585b86c9c
--- /dev/null
+++ b/src/main/scala/query/LibraryQuery.scala
@@ -0,0 +1,253 @@
+package query
+
+import lib.EmployeeManagerEmployee
+import lib.Library
+import lib.HelperPerson
+import lib.Person
+import lib.LibraryEmployeesEmployee
+import org.rosi_project.model_management.sum.query.IQueryViewCompartment
+import lib.Employee
+import org.rosi_project.model_management.sum.query.CheckingOption
+
+class LibraryQuery extends IQueryViewCompartment {
+
+  init("LibraryQuery")
+
+  def createLibrary(): LibraryQuery#LibraryRole = {
+    return new LibraryRole()
+  }
+
+  def createEmployee(): LibraryQuery#EmployeeRole = {
+    return new EmployeeRole()
+  }
+
+  def createPerson(): LibraryQuery#PersonRole = {
+    return new PersonRole()
+  }
+
+  override def toString(): String = {
+    "LibraryQuery:"
+  }
+
+  class LibraryRole extends AQueryViewRole {
+
+    private var employees: Set[LibraryQuery#LibraryEmployeesEmployeeRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Library(null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      employees.foreach(_.deleteElement())
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    private[LibraryQuery] def removeEmployeesIntern(v: LibraryQuery#LibraryEmployeesEmployeeRole): Unit = {
+      employees -= v
+    }
+
+    private[LibraryQuery] def setEmployeesIntern(v: LibraryQuery#LibraryEmployeesEmployeeRole): Unit = {
+      employees += v
+    }
+
+    def getEmployees(): Set[LibraryQuery#EmployeeRole] = {
+      var vs: Set[LibraryQuery#EmployeeRole] = Set.empty
+      employees.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasEmployees(v: LibraryQuery#EmployeeRole): Boolean = {
+      return getEmployees.contains(v)
+    }
+
+    def addEmployees(v: LibraryQuery#EmployeeRole): Boolean = {
+      if (hasEmployees(v) || !containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      new LibraryEmployeesEmployeeRole(this, v)
+      return true
+    }
+
+    def removeEmployees(v: LibraryQuery#EmployeeRole): Boolean = {
+      if (!hasEmployees(v)) return false
+      employees.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override def toString(): String = {
+      "LibraryRole:"
+    }
+
+  }
+
+  class EmployeeRole extends PersonRole() {
+
+    private var manager: LibraryQuery#EmployeeManagerEmployeeRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Employee(0, null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+      if (manager != null) manager.deleteElement()
+    }
+
+    def getSalaryView(): Double = {
+      +this getSalary ()
+    }
+
+    def setSalaryView(salary: Double, check: CheckingOption.Value): Unit = {
+      +this setSalary (salary)
+      connected.addAttributeFilter("salary", salary.toString(), check)
+    }
+
+    private[LibraryQuery] def removeManagerIntern(v: LibraryQuery#EmployeeManagerEmployeeRole): Unit = {
+      manager = null
+    }
+
+    private[LibraryQuery] def setManagerIntern(v: LibraryQuery#EmployeeManagerEmployeeRole): Unit = {
+      manager = v
+    }
+
+    def getManager(): LibraryQuery#EmployeeRole = {
+      return manager.getTarget()
+    }
+
+    def setManager(v: LibraryQuery#EmployeeRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AQueryViewRole])) return false
+      if (manager != null) {
+        if (manager.getTarget() == v) return false
+        manager.deleteElement()
+      }
+      new EmployeeManagerEmployeeRole(this, v)
+      return true
+    }
+
+    override def toString(): String = {
+      "EmployeeRole:"
+    }
+
+  }
+
+  class PersonRole extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new HelperPerson(null)
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String, check: CheckingOption.Value): Unit = {
+      +this setName (name)
+      connected.addAttributeFilter("name", name.toString(), check)
+    }
+
+    override def toString(): String = {
+      "PersonRole:"
+    }
+
+  }
+
+  class LibraryEmployeesEmployeeRole(private val source: LibraryQuery#LibraryRole, private val target: LibraryQuery#EmployeeRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setEmployeesIntern(this)
+      val sp: Library = source.player.right.get.asInstanceOf[Library]
+      val tp: Employee = target.player.right.get.asInstanceOf[Employee]
+      val v: LibraryEmployeesEmployee = new LibraryEmployeesEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeEmployeesIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): LibraryQuery#LibraryRole = {
+      source
+    }
+
+    def getTarget(): LibraryQuery#EmployeeRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "LibraryEmployeesEmployeeRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+  class EmployeeManagerEmployeeRole(private val source: LibraryQuery#EmployeeRole, private val target: LibraryQuery#EmployeeRole) extends AQueryViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setManagerIntern(this)
+      val sp: Employee = source.player.right.get.asInstanceOf[Employee]
+      val tp: Employee = target.player.right.get.asInstanceOf[Employee]
+      val v: EmployeeManagerEmployee = new EmployeeManagerEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeManagerIntern(this)
+      super.deleteElement()
+    }
+
+    def getSource(): LibraryQuery#EmployeeRole = {
+      source
+    }
+
+    def getTarget(): LibraryQuery#EmployeeRole = {
+      target
+    }
+
+    override def toString(): String = {
+      "EmployeeManagerEmployeeRole:" + " source=" + source + " target=" + target
+    }
+
+  }
+
+}
+
+
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/AMLLanguageView.scala b/src/main/scala/view/AMLLanguageView.scala
new file mode 100644
index 0000000000000000000000000000000000000000..0f923fb1cd448cf741d3c7550e4bbb4ebb38ae4f
--- /dev/null
+++ b/src/main/scala/view/AMLLanguageView.scala
@@ -0,0 +1,463 @@
+package view
+
+import org.rosi_project.model_management.sum.IViewCompartment
+import aml.SystemUnitClassInternalElementsInternalElement
+import aml.InternalElement
+import aml.SystemUnitClassAttributesAttribute
+import aml.CAEXObject
+import aml.Attribute
+import aml.InstanceHierarchyInternalElementsInternalElement
+import aml.InternalElementBaseSystemUnitSystemUnitClass
+import aml.InstanceHierarchy
+import aml.SystemUnitClass
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+class AMLLanguageView private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[SystemUnitClassInternalElementsInternalElement] || className.isInstanceOf[InternalElementBaseSystemUnitSystemUnitClass] || className.isInstanceOf[InstanceHierarchyInternalElementsInternalElement] || className.isInstanceOf[SystemUnitClass] || className.isInstanceOf[SystemUnitClassAttributesAttribute] || className.isInstanceOf[InstanceHierarchy] || className.isInstanceOf[Attribute] || className.isInstanceOf[InternalElement]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    AMLLanguageView.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[SystemUnitClass]) return new SystemUnitClassRole(null, null)
+    if (className.isInstanceOf[InternalElement]) return new InternalElementRole(null, null)
+    if (className.isInstanceOf[Attribute]) return new AttributeRole(null, null, null)
+    if (className.isInstanceOf[InstanceHierarchy]) return new InstanceHierarchyRole(null, null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[SystemUnitClassInternalElementsInternalElement]) return new SystemUnitClassInternalElementsInternalElementRole(sourceRole.asInstanceOf[SystemUnitClassRole], targetRole.asInstanceOf[InternalElementRole])
+    if (className.isInstanceOf[SystemUnitClassAttributesAttribute]) return new SystemUnitClassAttributesAttributeRole(sourceRole.asInstanceOf[SystemUnitClassRole], targetRole.asInstanceOf[AttributeRole])
+    if (className.isInstanceOf[InstanceHierarchyInternalElementsInternalElement]) return new InstanceHierarchyInternalElementsInternalElementRole(sourceRole.asInstanceOf[InstanceHierarchyRole], targetRole.asInstanceOf[InternalElementRole])
+    if (className.isInstanceOf[InternalElementBaseSystemUnitSystemUnitClass]) return new InternalElementBaseSystemUnitSystemUnitClassRole(sourceRole.asInstanceOf[InternalElementRole], targetRole.asInstanceOf[SystemUnitClassRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: AMLLanguageView"
+  }
+
+  def createSystemUnitClass(name: String, id: String): AMLLanguageView#SystemUnitClassRole = {
+    return new SystemUnitClassRole(name, id)
+  }
+
+  def createInternalElement(name: String, id: String): AMLLanguageView#InternalElementRole = {
+    return new InternalElementRole(name, id)
+  }
+
+  def createAttribute(value: String, name: String, id: String): AMLLanguageView#AttributeRole = {
+    return new AttributeRole(value, name, id)
+  }
+
+  def createInstanceHierarchy(name: String, id: String): AMLLanguageView#InstanceHierarchyRole = {
+    return new InstanceHierarchyRole(name, id)
+  }
+
+  class SystemUnitClassRole(c_Name: String, c_Id: String) extends CAEXObjectRole(c_Name, c_Id) {
+
+    private var internalElements: Set[AMLLanguageView#SystemUnitClassInternalElementsInternalElementRole] = Set.empty
+    private var attributes: Set[AMLLanguageView#SystemUnitClassAttributesAttributeRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new SystemUnitClass(name, id)
+    }
+
+    override def toString(): String = {
+      "VNR: SystemUnitClassRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[AMLLanguageView] def removeInternalElementsIntern(v: AMLLanguageView#SystemUnitClassInternalElementsInternalElementRole): Unit = {
+      internalElements -= v
+    }
+
+    private[AMLLanguageView] def setInternalElementsIntern(v: AMLLanguageView#SystemUnitClassInternalElementsInternalElementRole): Unit = {
+      internalElements += v
+    }
+
+    def getInternalElements(): Set[AMLLanguageView#InternalElementRole] = {
+      var vs: Set[AMLLanguageView#InternalElementRole] = Set.empty
+      internalElements.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasInternalElements(v: AMLLanguageView#InternalElementRole): Boolean = {
+      return getInternalElements.contains(v)
+    }
+
+    def addInternalElements(v: AMLLanguageView#InternalElementRole): Boolean = {
+      if (hasInternalElements(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new SystemUnitClassInternalElementsInternalElementRole(this, v)
+      return true
+    }
+
+    def removeInternalElements(v: AMLLanguageView#InternalElementRole): Boolean = {
+      if (!hasInternalElements(v)) return false
+      internalElements.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[AMLLanguageView] def removeAttributesIntern(v: AMLLanguageView#SystemUnitClassAttributesAttributeRole): Unit = {
+      attributes -= v
+    }
+
+    private[AMLLanguageView] def setAttributesIntern(v: AMLLanguageView#SystemUnitClassAttributesAttributeRole): Unit = {
+      attributes += v
+    }
+
+    def getAttributes(): Set[AMLLanguageView#AttributeRole] = {
+      var vs: Set[AMLLanguageView#AttributeRole] = Set.empty
+      attributes.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasAttributes(v: AMLLanguageView#AttributeRole): Boolean = {
+      return getAttributes.contains(v)
+    }
+
+    def addAttributes(v: AMLLanguageView#AttributeRole): Boolean = {
+      if (hasAttributes(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new SystemUnitClassAttributesAttributeRole(this, v)
+      return true
+    }
+
+    def removeAttributes(v: AMLLanguageView#AttributeRole): Boolean = {
+      if (!hasAttributes(v)) return false
+      attributes.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class AttributeRole(protected val value: String, c_Name: String, c_Id: String) extends CAEXObjectRole(c_Name, c_Id) {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Attribute(value, name, id)
+    }
+
+    override def toString(): String = {
+      "VNR: AttributeRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getValueView(): String = {
+      +this getValue ()
+    }
+
+    def setValueView(value: String): Unit = {
+      +this setValue (value)
+      +this changeSomething ()
+    }
+
+  }
+
+  class InstanceHierarchyRole(c_Name: String, c_Id: String) extends CAEXObjectRole(c_Name, c_Id) {
+
+    private var internalElements: Set[AMLLanguageView#InstanceHierarchyInternalElementsInternalElementRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new InstanceHierarchy(name, id)
+    }
+
+    override def toString(): String = {
+      "VNR: InstanceHierarchyRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[AMLLanguageView] def removeInternalElementsIntern(v: AMLLanguageView#InstanceHierarchyInternalElementsInternalElementRole): Unit = {
+      internalElements -= v
+    }
+
+    private[AMLLanguageView] def setInternalElementsIntern(v: AMLLanguageView#InstanceHierarchyInternalElementsInternalElementRole): Unit = {
+      internalElements += v
+    }
+
+    def getInternalElements(): Set[AMLLanguageView#InternalElementRole] = {
+      var vs: Set[AMLLanguageView#InternalElementRole] = Set.empty
+      internalElements.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasInternalElements(v: AMLLanguageView#InternalElementRole): Boolean = {
+      return getInternalElements.contains(v)
+    }
+
+    def addInternalElements(v: AMLLanguageView#InternalElementRole): Boolean = {
+      if (hasInternalElements(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new InstanceHierarchyInternalElementsInternalElementRole(this, v)
+      return true
+    }
+
+    def removeInternalElements(v: AMLLanguageView#InternalElementRole): Boolean = {
+      if (!hasInternalElements(v)) return false
+      internalElements.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  abstract class CAEXObjectRole(protected val name: String, protected val id: String) extends AViewRole {
+
+    override def toString(): String = {
+      "VNR: CAEXObjectRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+    def getIdView(): String = {
+      +this getId ()
+    }
+
+    def setIdView(id: String): Unit = {
+      +this setId (id)
+      +this changeSomething ()
+    }
+
+  }
+
+  class InternalElementRole(s_Name: String, s_Id: String) extends SystemUnitClassRole(s_Name, s_Id) {
+
+    private var baseSystemUnit: AMLLanguageView#InternalElementBaseSystemUnitSystemUnitClassRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new InternalElement(name, id)
+    }
+
+    override def toString(): String = {
+      "VNR: InternalElementRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[AMLLanguageView] def removeBaseSystemUnitIntern(v: AMLLanguageView#InternalElementBaseSystemUnitSystemUnitClassRole): Unit = {
+      baseSystemUnit = null
+    }
+
+    private[AMLLanguageView] def setBaseSystemUnitIntern(v: AMLLanguageView#InternalElementBaseSystemUnitSystemUnitClassRole): Unit = {
+      baseSystemUnit = v
+    }
+
+    def getBaseSystemUnit(): AMLLanguageView#SystemUnitClassRole = {
+      return baseSystemUnit.getTarget()
+    }
+
+    def setBaseSystemUnit(v: AMLLanguageView#SystemUnitClassRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (baseSystemUnit != null) {
+        if (baseSystemUnit.getTarget() == v) return false
+        baseSystemUnit.deleteElement()
+      }
+      new InternalElementBaseSystemUnitSystemUnitClassRole(this, v)
+      return true
+    }
+
+  }
+
+  class SystemUnitClassInternalElementsInternalElementRole(private val source: AMLLanguageView#SystemUnitClassRole, private val target: AMLLanguageView#InternalElementRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setInternalElementsIntern(this)
+      val sp: SystemUnitClass = getPlayerOfType(source, "SystemUnitClass").asInstanceOf[SystemUnitClass]
+      val tp: InternalElement = getPlayerOfType(target, "InternalElement").asInstanceOf[InternalElement]
+      val v: SystemUnitClassInternalElementsInternalElement = new SystemUnitClassInternalElementsInternalElement(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeInternalElementsIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: SystemUnitClassInternalElementsInternalElementRole"
+    }
+
+    def getSource(): AMLLanguageView#SystemUnitClassRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageView#InternalElementRole = {
+      target
+    }
+
+  }
+
+  class SystemUnitClassAttributesAttributeRole(private val source: AMLLanguageView#SystemUnitClassRole, private val target: AMLLanguageView#AttributeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setAttributesIntern(this)
+      val sp: SystemUnitClass = getPlayerOfType(source, "SystemUnitClass").asInstanceOf[SystemUnitClass]
+      val tp: Attribute = getPlayerOfType(target, "Attribute").asInstanceOf[Attribute]
+      val v: SystemUnitClassAttributesAttribute = new SystemUnitClassAttributesAttribute(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeAttributesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: SystemUnitClassAttributesAttributeRole"
+    }
+
+    def getSource(): AMLLanguageView#SystemUnitClassRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageView#AttributeRole = {
+      target
+    }
+
+  }
+
+  class InstanceHierarchyInternalElementsInternalElementRole(private val source: AMLLanguageView#InstanceHierarchyRole, private val target: AMLLanguageView#InternalElementRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setInternalElementsIntern(this)
+      val sp: InstanceHierarchy = getPlayerOfType(source, "InstanceHierarchy").asInstanceOf[InstanceHierarchy]
+      val tp: InternalElement = getPlayerOfType(target, "InternalElement").asInstanceOf[InternalElement]
+      val v: InstanceHierarchyInternalElementsInternalElement = new InstanceHierarchyInternalElementsInternalElement(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeInternalElementsIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: InstanceHierarchyInternalElementsInternalElementRole"
+    }
+
+    def getSource(): AMLLanguageView#InstanceHierarchyRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageView#InternalElementRole = {
+      target
+    }
+
+  }
+
+  class InternalElementBaseSystemUnitSystemUnitClassRole(private val source: AMLLanguageView#InternalElementRole, private val target: AMLLanguageView#SystemUnitClassRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBaseSystemUnitIntern(this)
+      val sp: InternalElement = getPlayerOfType(source, "InternalElement").asInstanceOf[InternalElement]
+      val tp: SystemUnitClass = getPlayerOfType(target, "SystemUnitClass").asInstanceOf[SystemUnitClass]
+      val v: InternalElementBaseSystemUnitSystemUnitClass = new InternalElementBaseSystemUnitSystemUnitClass(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBaseSystemUnitIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: InternalElementBaseSystemUnitSystemUnitClassRole"
+    }
+
+    def getSource(): AMLLanguageView#InternalElementRole = {
+      source
+    }
+
+    def getTarget(): AMLLanguageView#SystemUnitClassRole = {
+      target
+    }
+
+  }
+
+}
+
+object AMLLanguageView extends IViewTypeInfo {
+
+  override def getViewName(): String = "AMLLanguageView"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set.empty
+
+  protected def getNewInstance(): IViewCompartment = new AMLLanguageView()
+
+  def getNewView(): AMLLanguageView = getNewViewTypeInstance().asInstanceOf[AMLLanguageView]
+}
+     
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/EclipseLibraryView.scala b/src/main/scala/view/EclipseLibraryView.scala
new file mode 100644
index 0000000000000000000000000000000000000000..4c6e617d8e9dd6a74410caaeee0b680908797da0
--- /dev/null
+++ b/src/main/scala/view/EclipseLibraryView.scala
@@ -0,0 +1,1312 @@
+package view
+
+import elib.BookAuthorWriter
+import org.rosi_project.model_management.sum.IViewCompartment
+import elib.BookCategory
+import elib.BookOnTapeReaderPerson
+import elib.Employee
+import elib.LibraryBranchesLibrary
+import elib.VideoCassette
+import elib.BookOnTapeAuthorWriter
+import elib.LibraryBooksBook
+import elib.LibraryBorrowersBorrower
+import elib.Borrower
+import elib.LibraryParentBranchLibrary
+import elib.Periodical
+import elib.Writer
+import elib.AudioVisualItem
+import elib.EmployeeManagerEmployee
+import elib.Person
+import java.util.Date
+import elib.BookOnTape
+import elib.VideoCassetteCastPerson
+import elib.Library
+import elib.Book
+import elib.LibraryWritersWriter
+import elib.LibraryEmployeesEmployee
+import elib.CirculatingItem
+import elib.Item
+import elib.LibraryStockItem
+
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+class EclipseLibraryView private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[LibraryStockItem] || className.isInstanceOf[EmployeeManagerEmployee] || className.isInstanceOf[Writer] || className.isInstanceOf[LibraryWritersWriter] || className.isInstanceOf[BookAuthorWriter] || className.isInstanceOf[BookOnTapeAuthorWriter] || className.isInstanceOf[Person] || className.isInstanceOf[LibraryEmployeesEmployee] || className.isInstanceOf[Borrower] || className.isInstanceOf[BookOnTape] || className.isInstanceOf[CirculatingItem] || className.isInstanceOf[Library] || className.isInstanceOf[LibraryBranchesLibrary] || className.isInstanceOf[BookOnTapeReaderPerson] || className.isInstanceOf[Periodical] || className.isInstanceOf[LibraryBooksBook] || className.isInstanceOf[VideoCassette] || className.isInstanceOf[AudioVisualItem] || className.isInstanceOf[Book] || className.isInstanceOf[LibraryParentBranchLibrary] || className.isInstanceOf[Employee] || className.isInstanceOf[LibraryBorrowersBorrower] || className.isInstanceOf[VideoCassetteCastPerson] || className.isInstanceOf[Item]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    EclipseLibraryView.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[Library]) return new LibraryRole(null)
+    if (className.isInstanceOf[Periodical]) return new PeriodicalRole(0, null, null)
+    if (className.isInstanceOf[Person]) return new PersonRole(null, null)
+    if (className.isInstanceOf[Borrower]) return new BorrowerRole(null, null)
+    if (className.isInstanceOf[Item]) return new ItemRole(null)
+    if (className.isInstanceOf[AudioVisualItem]) return new AudioVisualItemRole(false, 0, null, null)
+    if (className.isInstanceOf[CirculatingItem]) return new CirculatingItemRole(null)
+    if (className.isInstanceOf[BookOnTape]) return new BookOnTapeRole(false, 0, null, null)
+    if (className.isInstanceOf[VideoCassette]) return new VideoCassetteRole(false, 0, null, null)
+    if (className.isInstanceOf[Book]) return new BookRole(null, 0, null, null)
+    if (className.isInstanceOf[Writer]) return new WriterRole(null, null, null)
+    if (className.isInstanceOf[Employee]) return new EmployeeRole(null, null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[EmployeeManagerEmployee]) return new EmployeeManagerEmployeeRole(sourceRole.asInstanceOf[EmployeeRole], targetRole.asInstanceOf[EmployeeRole])
+    if (className.isInstanceOf[LibraryStockItem]) return new LibraryStockItemRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[ItemRole])
+    if (className.isInstanceOf[LibraryWritersWriter]) return new LibraryWritersWriterRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[WriterRole])
+    if (className.isInstanceOf[LibraryBooksBook]) return new LibraryBooksBookRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[BookRole])
+    if (className.isInstanceOf[LibraryParentBranchLibrary]) return new LibraryParentBranchLibraryRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[LibraryRole])
+    if (className.isInstanceOf[LibraryBranchesLibrary]) return new LibraryBranchesLibraryRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[LibraryRole])
+    if (className.isInstanceOf[LibraryEmployeesEmployee]) return new LibraryEmployeesEmployeeRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[EmployeeRole])
+    if (className.isInstanceOf[BookAuthorWriter]) return new BookAuthorWriterRole(sourceRole.asInstanceOf[BookRole], targetRole.asInstanceOf[WriterRole])
+    if (className.isInstanceOf[VideoCassetteCastPerson]) return new VideoCassetteCastPersonRole(sourceRole.asInstanceOf[VideoCassetteRole], targetRole.asInstanceOf[PersonRole])
+    if (className.isInstanceOf[BookOnTapeAuthorWriter]) return new BookOnTapeAuthorWriterRole(sourceRole.asInstanceOf[BookOnTapeRole], targetRole.asInstanceOf[WriterRole])
+    if (className.isInstanceOf[BookOnTapeReaderPerson]) return new BookOnTapeReaderPersonRole(sourceRole.asInstanceOf[BookOnTapeRole], targetRole.asInstanceOf[PersonRole])
+    if (className.isInstanceOf[LibraryBorrowersBorrower]) return new LibraryBorrowersBorrowerRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[BorrowerRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: EclipseLibraryView"
+  }
+
+  def createLibrary(name: String): EclipseLibraryView#LibraryRole = {
+    return new LibraryRole(name)
+  }
+
+  def createPeriodical(issuesPerYear: Int, title: String, publicationDate: Date): EclipseLibraryView#PeriodicalRole = {
+    return new PeriodicalRole(issuesPerYear, title, publicationDate)
+  }
+
+  def createPerson(lastName: String, firstName: String): EclipseLibraryView#PersonRole = {
+    return new PersonRole(lastName, firstName)
+  }
+
+  def createBorrower(lastName: String, firstName: String): EclipseLibraryView#BorrowerRole = {
+    return new BorrowerRole(lastName, firstName)
+  }
+
+  def createItem(publicationDate: Date): EclipseLibraryView#ItemRole = {
+    return new ItemRole(publicationDate)
+  }
+
+  def createAudioVisualItem(damaged: Boolean, minutesLength: Int, title: String, publicationDate: Date): EclipseLibraryView#AudioVisualItemRole = {
+    return new AudioVisualItemRole(damaged, minutesLength, title, publicationDate)
+  }
+
+  def createCirculatingItem(publicationDate: Date): EclipseLibraryView#CirculatingItemRole = {
+    return new CirculatingItemRole(publicationDate)
+  }
+
+  def createBookOnTape(damaged: Boolean, minutesLength: Int, title: String, publicationDate: Date): EclipseLibraryView#BookOnTapeRole = {
+    return new BookOnTapeRole(damaged, minutesLength, title, publicationDate)
+  }
+
+  def createVideoCassette(damaged: Boolean, minutesLength: Int, title: String, publicationDate: Date): EclipseLibraryView#VideoCassetteRole = {
+    return new VideoCassetteRole(damaged, minutesLength, title, publicationDate)
+  }
+
+  def createBook(category: BookCategory.Value, pages: Int, title: String, publicationDate: Date): EclipseLibraryView#BookRole = {
+    return new BookRole(category, pages, title, publicationDate)
+  }
+
+  def createWriter(name: String, lastName: String, firstName: String): EclipseLibraryView#WriterRole = {
+    return new WriterRole(name, lastName, firstName)
+  }
+
+  def createEmployee(lastName: String, firstName: String): EclipseLibraryView#EmployeeRole = {
+    return new EmployeeRole(lastName, firstName)
+  }
+
+  class ItemRole(protected val publicationDate: Date) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Item(publicationDate)
+    }
+
+    override def toString(): String = {
+      "VNR: ItemRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getPublicationDateView(): Date = {
+      +this getPublicationDate ()
+    }
+
+    def setPublicationDateView(publicationdate: Date): Unit = {
+      +this setPublicationDate (publicationdate)
+      +this changeSomething ()
+    }
+
+  }
+
+  class EmployeeRole(p_LastName: String, p_FirstName: String) extends PersonRole(p_LastName, p_FirstName) {
+
+    private var manager: EclipseLibraryView#EmployeeManagerEmployeeRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Employee(lastName, firstName)
+    }
+
+    override def toString(): String = {
+      "VNR: EmployeeRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[EclipseLibraryView] def removeManagerIntern(v: EclipseLibraryView#EmployeeManagerEmployeeRole): Unit = {
+      manager = null
+    }
+
+    private[EclipseLibraryView] def setManagerIntern(v: EclipseLibraryView#EmployeeManagerEmployeeRole): Unit = {
+      manager = v
+    }
+
+    def getManager(): EclipseLibraryView#EmployeeRole = {
+      return manager.getTarget()
+    }
+
+    def setManager(v: EclipseLibraryView#EmployeeRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (manager != null) {
+        if (manager.getTarget() == v) return false
+        manager.deleteElement()
+      }
+      new EmployeeManagerEmployeeRole(this, v)
+      return true
+    }
+
+  }
+
+  class PeriodicalRole(protected val issuesPerYear: Int, protected val title: String, i_PublicationDate: Date) extends ItemRole(i_PublicationDate) {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Periodical(issuesPerYear, title, publicationDate)
+    }
+
+    override def toString(): String = {
+      "VNR: PeriodicalRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getIssuesPerYearView(): Int = {
+      +this getIssuesPerYear ()
+    }
+
+    def setIssuesPerYearView(issuesperyear: Int): Unit = {
+      +this setIssuesPerYear (issuesperyear)
+      +this changeSomething ()
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String): Unit = {
+      +this setTitle (title)
+      +this changeSomething ()
+    }
+
+  }
+
+  class VideoCassetteRole(a_Damaged: Boolean, a_MinutesLength: Int, a_Title: String, a_PublicationDate: Date) extends AudioVisualItemRole(a_Damaged, a_MinutesLength, a_Title, a_PublicationDate) {
+
+    private var cast: Set[EclipseLibraryView#VideoCassetteCastPersonRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new VideoCassette(damaged, minutesLength, title, null)
+    }
+
+    override def toString(): String = {
+      "VNR: VideoCassetteRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[EclipseLibraryView] def removeCastIntern(v: EclipseLibraryView#VideoCassetteCastPersonRole): Unit = {
+      cast -= v
+    }
+
+    private[EclipseLibraryView] def setCastIntern(v: EclipseLibraryView#VideoCassetteCastPersonRole): Unit = {
+      cast += v
+    }
+
+    def getCast(): Set[EclipseLibraryView#PersonRole] = {
+      var vs: Set[EclipseLibraryView#PersonRole] = Set.empty
+      cast.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasCast(v: EclipseLibraryView#PersonRole): Boolean = {
+      return getCast.contains(v)
+    }
+
+    def addCast(v: EclipseLibraryView#PersonRole): Boolean = {
+      if (hasCast(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new VideoCassetteCastPersonRole(this, v)
+      return true
+    }
+
+    def removeCast(v: EclipseLibraryView#PersonRole): Boolean = {
+      if (!hasCast(v)) return false
+      cast.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class AudioVisualItemRole(protected val damaged: Boolean, protected val minutesLength: Int, protected val title: String, c_PublicationDate: Date) extends CirculatingItemRole(c_PublicationDate) {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new AudioVisualItem(damaged, minutesLength, title, null)
+    }
+
+    override def toString(): String = {
+      "VNR: AudioVisualItemRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getDamagedView(): Boolean = {
+      +this getDamaged ()
+    }
+
+    def setDamagedView(damaged: Boolean): Unit = {
+      +this setDamaged (damaged)
+      +this changeSomething ()
+    }
+
+    def getMinutesLengthView(): Int = {
+      +this getMinutesLength ()
+    }
+
+    def setMinutesLengthView(minuteslength: Int): Unit = {
+      +this setMinutesLength (minuteslength)
+      +this changeSomething ()
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String): Unit = {
+      +this setTitle (title)
+      +this changeSomething ()
+    }
+
+  }
+
+  class WriterRole(protected val name: String, p_LastName: String, p_FirstName: String) extends PersonRole(p_LastName, p_FirstName) {
+
+    private var books: Set[EclipseLibraryView#BookAuthorWriterRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Writer(name, lastName, firstName)
+    }
+
+    override def toString(): String = {
+      "VNR: WriterRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+    private[EclipseLibraryView] def removeBooksIntern(v: EclipseLibraryView#BookAuthorWriterRole): Unit = {
+      books -= v
+    }
+
+    private[EclipseLibraryView] def setBooksIntern(v: EclipseLibraryView#BookAuthorWriterRole): Unit = {
+      books += v
+    }
+
+    def getBooks(): Set[EclipseLibraryView#BookRole] = {
+      var vs: Set[EclipseLibraryView#BookRole] = Set.empty
+      books.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasBooks(v: EclipseLibraryView#BookRole): Boolean = {
+      return getBooks.contains(v)
+    }
+
+    def addBooks(v: EclipseLibraryView#BookRole): Boolean = {
+      if (hasBooks(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new BookAuthorWriterRole(v, this)
+      return true
+    }
+
+    def removeBooks(v: EclipseLibraryView#BookRole): Boolean = {
+      if (!hasBooks(v)) return false
+      books.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class BookRole(protected val category: BookCategory.Value, protected val pages: Int, protected val title: String, c_PublicationDate: Date) extends CirculatingItemRole(c_PublicationDate) {
+
+    private var author: EclipseLibraryView#BookAuthorWriterRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Book(category, pages, title, null)
+    }
+
+    override def toString(): String = {
+      "VNR: BookRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getCategoryView(): BookCategory.Value = {
+      +this getCategory ()
+    }
+
+    def setCategoryView(category: BookCategory.Value): Unit = {
+      +this setCategory (category)
+      +this changeSomething ()
+    }
+
+    def getPagesView(): Int = {
+      +this getPages ()
+    }
+
+    def setPagesView(pages: Int): Unit = {
+      +this setPages (pages)
+      +this changeSomething ()
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String): Unit = {
+      +this setTitle (title)
+      +this changeSomething ()
+    }
+
+    private[EclipseLibraryView] def removeAuthorIntern(v: EclipseLibraryView#BookAuthorWriterRole): Unit = {
+      author = null
+    }
+
+    private[EclipseLibraryView] def setAuthorIntern(v: EclipseLibraryView#BookAuthorWriterRole): Unit = {
+      author = v
+    }
+
+    def getAuthor(): EclipseLibraryView#WriterRole = {
+      return author.getTarget()
+    }
+
+    def setAuthor(v: EclipseLibraryView#WriterRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (author != null) {
+        if (author.getTarget() == v) return false
+        author.deleteElement()
+      }
+      new BookAuthorWriterRole(this, v)
+      return true
+    }
+
+  }
+
+  class LibraryRole(protected val name: String) extends AViewRole {
+
+    private var employees: Set[EclipseLibraryView#LibraryEmployeesEmployeeRole] = Set.empty
+    private var parentBranch: EclipseLibraryView#LibraryParentBranchLibraryRole = null
+    private var writers: Set[EclipseLibraryView#LibraryWritersWriterRole] = Set.empty
+    private var borrowers: Set[EclipseLibraryView#LibraryBorrowersBorrowerRole] = Set.empty
+    private var stock: Set[EclipseLibraryView#LibraryStockItemRole] = Set.empty
+    private var branches: Set[EclipseLibraryView#LibraryBranchesLibraryRole] = Set.empty
+    private var books: Set[EclipseLibraryView#LibraryBooksBookRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Library(name)
+    }
+
+    override def toString(): String = {
+      "VNR: LibraryRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+    private[EclipseLibraryView] def removeEmployeesIntern(v: EclipseLibraryView#LibraryEmployeesEmployeeRole): Unit = {
+      employees -= v
+    }
+
+    private[EclipseLibraryView] def setEmployeesIntern(v: EclipseLibraryView#LibraryEmployeesEmployeeRole): Unit = {
+      employees += v
+    }
+
+    def getEmployees(): Set[EclipseLibraryView#EmployeeRole] = {
+      var vs: Set[EclipseLibraryView#EmployeeRole] = Set.empty
+      employees.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasEmployees(v: EclipseLibraryView#EmployeeRole): Boolean = {
+      return getEmployees.contains(v)
+    }
+
+    def addEmployees(v: EclipseLibraryView#EmployeeRole): Boolean = {
+      if (hasEmployees(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryEmployeesEmployeeRole(this, v)
+      return true
+    }
+
+    def removeEmployees(v: EclipseLibraryView#EmployeeRole): Boolean = {
+      if (!hasEmployees(v)) return false
+      employees.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryView] def removeParentBranchIntern(v: EclipseLibraryView#LibraryParentBranchLibraryRole): Unit = {
+      parentBranch = null
+    }
+
+    private[EclipseLibraryView] def setParentBranchIntern(v: EclipseLibraryView#LibraryParentBranchLibraryRole): Unit = {
+      parentBranch = v
+    }
+
+    def getParentBranch(): EclipseLibraryView#LibraryRole = {
+      return parentBranch.getTarget()
+    }
+
+    def setParentBranch(v: EclipseLibraryView#LibraryRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (parentBranch != null) {
+        if (parentBranch.getTarget() == v) return false
+        parentBranch.deleteElement()
+      }
+      new LibraryParentBranchLibraryRole(this, v)
+      return true
+    }
+
+    private[EclipseLibraryView] def removeWritersIntern(v: EclipseLibraryView#LibraryWritersWriterRole): Unit = {
+      writers -= v
+    }
+
+    private[EclipseLibraryView] def setWritersIntern(v: EclipseLibraryView#LibraryWritersWriterRole): Unit = {
+      writers += v
+    }
+
+    def getWriters(): Set[EclipseLibraryView#WriterRole] = {
+      var vs: Set[EclipseLibraryView#WriterRole] = Set.empty
+      writers.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasWriters(v: EclipseLibraryView#WriterRole): Boolean = {
+      return getWriters.contains(v)
+    }
+
+    def addWriters(v: EclipseLibraryView#WriterRole): Boolean = {
+      if (hasWriters(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryWritersWriterRole(this, v)
+      return true
+    }
+
+    def removeWriters(v: EclipseLibraryView#WriterRole): Boolean = {
+      if (!hasWriters(v)) return false
+      writers.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryView] def removeBorrowersIntern(v: EclipseLibraryView#LibraryBorrowersBorrowerRole): Unit = {
+      borrowers -= v
+    }
+
+    private[EclipseLibraryView] def setBorrowersIntern(v: EclipseLibraryView#LibraryBorrowersBorrowerRole): Unit = {
+      borrowers += v
+    }
+
+    def getBorrowers(): Set[EclipseLibraryView#BorrowerRole] = {
+      var vs: Set[EclipseLibraryView#BorrowerRole] = Set.empty
+      borrowers.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasBorrowers(v: EclipseLibraryView#BorrowerRole): Boolean = {
+      return getBorrowers.contains(v)
+    }
+
+    def addBorrowers(v: EclipseLibraryView#BorrowerRole): Boolean = {
+      if (hasBorrowers(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryBorrowersBorrowerRole(this, v)
+      return true
+    }
+
+    def removeBorrowers(v: EclipseLibraryView#BorrowerRole): Boolean = {
+      if (!hasBorrowers(v)) return false
+      borrowers.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryView] def removeStockIntern(v: EclipseLibraryView#LibraryStockItemRole): Unit = {
+      stock -= v
+    }
+
+    private[EclipseLibraryView] def setStockIntern(v: EclipseLibraryView#LibraryStockItemRole): Unit = {
+      stock += v
+    }
+
+    def getStock(): Set[EclipseLibraryView#ItemRole] = {
+      var vs: Set[EclipseLibraryView#ItemRole] = Set.empty
+      stock.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasStock(v: EclipseLibraryView#ItemRole): Boolean = {
+      return getStock.contains(v)
+    }
+
+    def addStock(v: EclipseLibraryView#ItemRole): Boolean = {
+      if (hasStock(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryStockItemRole(this, v)
+      return true
+    }
+
+    def removeStock(v: EclipseLibraryView#ItemRole): Boolean = {
+      if (!hasStock(v)) return false
+      stock.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryView] def removeBranchesIntern(v: EclipseLibraryView#LibraryBranchesLibraryRole): Unit = {
+      branches -= v
+    }
+
+    private[EclipseLibraryView] def setBranchesIntern(v: EclipseLibraryView#LibraryBranchesLibraryRole): Unit = {
+      branches += v
+    }
+
+    def getBranches(): Set[EclipseLibraryView#LibraryRole] = {
+      var vs: Set[EclipseLibraryView#LibraryRole] = Set.empty
+      branches.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasBranches(v: EclipseLibraryView#LibraryRole): Boolean = {
+      return getBranches.contains(v)
+    }
+
+    def addBranches(v: EclipseLibraryView#LibraryRole): Boolean = {
+      if (hasBranches(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryBranchesLibraryRole(this, v)
+      return true
+    }
+
+    def removeBranches(v: EclipseLibraryView#LibraryRole): Boolean = {
+      if (!hasBranches(v)) return false
+      branches.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[EclipseLibraryView] def removeBooksIntern(v: EclipseLibraryView#LibraryBooksBookRole): Unit = {
+      books -= v
+    }
+
+    private[EclipseLibraryView] def setBooksIntern(v: EclipseLibraryView#LibraryBooksBookRole): Unit = {
+      books += v
+    }
+
+    def getBooks(): Set[EclipseLibraryView#BookRole] = {
+      var vs: Set[EclipseLibraryView#BookRole] = Set.empty
+      books.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasBooks(v: EclipseLibraryView#BookRole): Boolean = {
+      return getBooks.contains(v)
+    }
+
+    def addBooks(v: EclipseLibraryView#BookRole): Boolean = {
+      if (hasBooks(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryBooksBookRole(this, v)
+      return true
+    }
+
+    def removeBooks(v: EclipseLibraryView#BookRole): Boolean = {
+      if (!hasBooks(v)) return false
+      books.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class BookOnTapeRole(a_Damaged: Boolean, a_MinutesLength: Int, a_Title: String, a_PublicationDate: Date) extends AudioVisualItemRole(a_Damaged, a_MinutesLength, a_Title, a_PublicationDate) {
+
+    private var author: EclipseLibraryView#BookOnTapeAuthorWriterRole = null
+    private var reader: EclipseLibraryView#BookOnTapeReaderPersonRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new BookOnTape(damaged, minutesLength, title, null)
+    }
+
+    override def toString(): String = {
+      "VNR: BookOnTapeRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[EclipseLibraryView] def removeAuthorIntern(v: EclipseLibraryView#BookOnTapeAuthorWriterRole): Unit = {
+      author = null
+    }
+
+    private[EclipseLibraryView] def setAuthorIntern(v: EclipseLibraryView#BookOnTapeAuthorWriterRole): Unit = {
+      author = v
+    }
+
+    def getAuthor(): EclipseLibraryView#WriterRole = {
+      return author.getTarget()
+    }
+
+    def setAuthor(v: EclipseLibraryView#WriterRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (author != null) {
+        if (author.getTarget() == v) return false
+        author.deleteElement()
+      }
+      new BookOnTapeAuthorWriterRole(this, v)
+      return true
+    }
+
+    private[EclipseLibraryView] def removeReaderIntern(v: EclipseLibraryView#BookOnTapeReaderPersonRole): Unit = {
+      reader = null
+    }
+
+    private[EclipseLibraryView] def setReaderIntern(v: EclipseLibraryView#BookOnTapeReaderPersonRole): Unit = {
+      reader = v
+    }
+
+    def getReader(): EclipseLibraryView#PersonRole = {
+      return reader.getTarget()
+    }
+
+    def setReader(v: EclipseLibraryView#PersonRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (reader != null) {
+        if (reader.getTarget() == v) return false
+        reader.deleteElement()
+      }
+      new BookOnTapeReaderPersonRole(this, v)
+      return true
+    }
+
+  }
+
+  class CirculatingItemRole(i_PublicationDate: Date) extends ItemRole(i_PublicationDate) {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new CirculatingItem(publicationDate)
+    }
+
+    override def toString(): String = {
+      "VNR: CirculatingItemRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+  }
+
+  class BorrowerRole(p_LastName: String, p_FirstName: String) extends PersonRole(p_LastName, p_FirstName) {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Borrower(lastName, firstName)
+    }
+
+    override def toString(): String = {
+      "VNR: BorrowerRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+  }
+
+  class PersonRole(protected val lastName: String, protected val firstName: String) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Person(lastName, firstName)
+    }
+
+    override def toString(): String = {
+      "VNR: PersonRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getLastNameView(): String = {
+      +this getLastName ()
+    }
+
+    def setLastNameView(lastname: String): Unit = {
+      +this setLastName (lastname)
+      +this changeSomething ()
+    }
+
+    def getFirstNameView(): String = {
+      +this getFirstName ()
+    }
+
+    def setFirstNameView(firstname: String): Unit = {
+      +this setFirstName (firstname)
+      +this changeSomething ()
+    }
+
+  }
+
+  class LibraryEmployeesEmployeeRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#EmployeeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setEmployeesIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Employee = getPlayerOfType(target, "Employee").asInstanceOf[Employee]
+      val v: LibraryEmployeesEmployee = new LibraryEmployeesEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeEmployeesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryEmployeesEmployeeRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#EmployeeRole = {
+      target
+    }
+
+  }
+
+  class LibraryParentBranchLibraryRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#LibraryRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setParentBranchIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Library = getPlayerOfType(target, "Library").asInstanceOf[Library]
+      val v: LibraryParentBranchLibrary = new LibraryParentBranchLibrary(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeParentBranchIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryParentBranchLibraryRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#LibraryRole = {
+      target
+    }
+
+  }
+
+  class LibraryWritersWriterRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#WriterRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setWritersIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Writer = getPlayerOfType(target, "Writer").asInstanceOf[Writer]
+      val v: LibraryWritersWriter = new LibraryWritersWriter(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeWritersIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryWritersWriterRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#WriterRole = {
+      target
+    }
+
+  }
+
+  class BookOnTapeAuthorWriterRole(private val source: EclipseLibraryView#BookOnTapeRole, private val target: EclipseLibraryView#WriterRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setAuthorIntern(this)
+      val sp: BookOnTape = getPlayerOfType(source, "BookOnTape").asInstanceOf[BookOnTape]
+      val tp: Writer = getPlayerOfType(target, "Writer").asInstanceOf[Writer]
+      val v: BookOnTapeAuthorWriter = new BookOnTapeAuthorWriter(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeAuthorIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: BookOnTapeAuthorWriterRole"
+    }
+
+    def getSource(): EclipseLibraryView#BookOnTapeRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#WriterRole = {
+      target
+    }
+
+  }
+
+  class BookOnTapeReaderPersonRole(private val source: EclipseLibraryView#BookOnTapeRole, private val target: EclipseLibraryView#PersonRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setReaderIntern(this)
+      val sp: BookOnTape = getPlayerOfType(source, "BookOnTape").asInstanceOf[BookOnTape]
+      val tp: Person = getPlayerOfType(target, "Person").asInstanceOf[Person]
+      val v: BookOnTapeReaderPerson = new BookOnTapeReaderPerson(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeReaderIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: BookOnTapeReaderPersonRole"
+    }
+
+    def getSource(): EclipseLibraryView#BookOnTapeRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#PersonRole = {
+      target
+    }
+
+  }
+
+  class LibraryBorrowersBorrowerRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#BorrowerRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBorrowersIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Borrower = getPlayerOfType(target, "Borrower").asInstanceOf[Borrower]
+      val v: LibraryBorrowersBorrower = new LibraryBorrowersBorrower(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBorrowersIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryBorrowersBorrowerRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#BorrowerRole = {
+      target
+    }
+
+  }
+
+  class LibraryStockItemRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#ItemRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setStockIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Item = getPlayerOfType(target, "Item").asInstanceOf[Item]
+      val v: LibraryStockItem = new LibraryStockItem(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeStockIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryStockItemRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#ItemRole = {
+      target
+    }
+
+  }
+
+  class BookAuthorWriterRole(private val source: EclipseLibraryView#BookRole, private val target: EclipseLibraryView#WriterRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setBooksIntern(this)
+      source.setAuthorIntern(this)
+      val sp: Book = getPlayerOfType(source, "Book").asInstanceOf[Book]
+      val tp: Writer = getPlayerOfType(target, "Writer").asInstanceOf[Writer]
+      val v: BookAuthorWriter = new BookAuthorWriter(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeAuthorIntern(this)
+      target.removeBooksIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: BookAuthorWriterRole"
+    }
+
+    def getSource(): EclipseLibraryView#BookRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#WriterRole = {
+      target
+    }
+
+  }
+
+  class LibraryBranchesLibraryRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#LibraryRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBranchesIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Library = getPlayerOfType(target, "Library").asInstanceOf[Library]
+      val v: LibraryBranchesLibrary = new LibraryBranchesLibrary(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBranchesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryBranchesLibraryRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#LibraryRole = {
+      target
+    }
+
+  }
+
+  class VideoCassetteCastPersonRole(private val source: EclipseLibraryView#VideoCassetteRole, private val target: EclipseLibraryView#PersonRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setCastIntern(this)
+      val sp: VideoCassette = getPlayerOfType(source, "VideoCassette").asInstanceOf[VideoCassette]
+      val tp: Person = getPlayerOfType(target, "Person").asInstanceOf[Person]
+      val v: VideoCassetteCastPerson = new VideoCassetteCastPerson(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeCastIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: VideoCassetteCastPersonRole"
+    }
+
+    def getSource(): EclipseLibraryView#VideoCassetteRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#PersonRole = {
+      target
+    }
+
+  }
+
+  class EmployeeManagerEmployeeRole(private val source: EclipseLibraryView#EmployeeRole, private val target: EclipseLibraryView#EmployeeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setManagerIntern(this)
+      val sp: Employee = getPlayerOfType(source, "Employee").asInstanceOf[Employee]
+      val tp: Employee = getPlayerOfType(target, "Employee").asInstanceOf[Employee]
+      val v: EmployeeManagerEmployee = new EmployeeManagerEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeManagerIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: EmployeeManagerEmployeeRole"
+    }
+
+    def getSource(): EclipseLibraryView#EmployeeRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#EmployeeRole = {
+      target
+    }
+
+  }
+
+  class LibraryBooksBookRole(private val source: EclipseLibraryView#LibraryRole, private val target: EclipseLibraryView#BookRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setBooksIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Book = getPlayerOfType(target, "Book").asInstanceOf[Book]
+      val v: LibraryBooksBook = new LibraryBooksBook(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeBooksIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryBooksBookRole"
+    }
+
+    def getSource(): EclipseLibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): EclipseLibraryView#BookRole = {
+      target
+    }
+
+  }
+
+}
+
+object EclipseLibraryView extends IViewTypeInfo {
+
+  override def getViewName(): String = "EclipseLibraryView"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set.empty
+
+  protected def getNewInstance(): IViewCompartment = new EclipseLibraryView()
+
+  def getNewView(): EclipseLibraryView = getNewViewTypeInstance().asInstanceOf[EclipseLibraryView]
+}
+      
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/IMDBdatabaseView.scala b/src/main/scala/view/IMDBdatabaseView.scala
new file mode 100644
index 0000000000000000000000000000000000000000..816ccc585ada0eb2bb4fd62f3c4bee03864256c3
--- /dev/null
+++ b/src/main/scala/view/IMDBdatabaseView.scala
@@ -0,0 +1,1055 @@
+package view
+
+import org.rosi_project.model_management.sum.IViewCompartment
+import imdbdatabase.User
+import imdbdatabase.IMDBFilmsFilm
+import imdbdatabase.FilmFiguresFigure
+import imdbdatabase.VoteFilmFilm
+import imdbdatabase.Film
+import imdbdatabase.IMDBVotesVote
+import imdbdatabase.VoteUserUser
+import imdbdatabase.FigurePlayedByActor
+import imdbdatabase.Person
+import imdbdatabase.IMDB
+import imdbdatabase.Figure
+import imdbdatabase.Actor
+import imdbdatabase.Vote
+import imdbdatabase.IMDBUsersUser
+import imdbdatabase.IMDBActorsActor
+
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+class IMDBdatabaseView private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[IMDBFilmsFilm] || className.isInstanceOf[IMDBVotesVote] || className.isInstanceOf[IMDBActorsActor] || className.isInstanceOf[FilmFiguresFigure] || className.isInstanceOf[Person] || className.isInstanceOf[IMDB] || className.isInstanceOf[Vote] || className.isInstanceOf[VoteUserUser] || className.isInstanceOf[FigurePlayedByActor] || className.isInstanceOf[User] || className.isInstanceOf[VoteFilmFilm] || className.isInstanceOf[IMDBUsersUser] || className.isInstanceOf[Actor] || className.isInstanceOf[Film] || className.isInstanceOf[Figure]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    IMDBdatabaseView.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[Figure]) return new FigureRole(null)
+    if (className.isInstanceOf[Actor]) return new ActorRole(0, null)
+    if (className.isInstanceOf[Person]) return new PersonRole(0, null)
+    if (className.isInstanceOf[User]) return new UserRole(null, null, 0, null)
+    if (className.isInstanceOf[Vote]) return new VoteRole(0)
+    if (className.isInstanceOf[IMDB]) return new IMDBRole()
+    if (className.isInstanceOf[Film]) return new FilmRole(0, null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[FilmFiguresFigure]) return new FilmFiguresFigureRole(sourceRole.asInstanceOf[FilmRole], targetRole.asInstanceOf[FigureRole])
+    if (className.isInstanceOf[IMDBVotesVote]) return new IMDBVotesVoteRole(sourceRole.asInstanceOf[IMDBRole], targetRole.asInstanceOf[VoteRole])
+    if (className.isInstanceOf[IMDBActorsActor]) return new IMDBActorsActorRole(sourceRole.asInstanceOf[IMDBRole], targetRole.asInstanceOf[ActorRole])
+    if (className.isInstanceOf[IMDBUsersUser]) return new IMDBUsersUserRole(sourceRole.asInstanceOf[IMDBRole], targetRole.asInstanceOf[UserRole])
+    if (className.isInstanceOf[VoteUserUser]) return new VoteUserUserRole(sourceRole.asInstanceOf[VoteRole], targetRole.asInstanceOf[UserRole])
+    if (className.isInstanceOf[VoteFilmFilm]) return new VoteFilmFilmRole(sourceRole.asInstanceOf[VoteRole], targetRole.asInstanceOf[FilmRole])
+    if (className.isInstanceOf[FigurePlayedByActor]) return new FigurePlayedByActorRole(sourceRole.asInstanceOf[FigureRole], targetRole.asInstanceOf[ActorRole])
+    if (className.isInstanceOf[IMDBFilmsFilm]) return new IMDBFilmsFilmRole(sourceRole.asInstanceOf[IMDBRole], targetRole.asInstanceOf[FilmRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: IMDBdatabaseView"
+  }
+
+  def createFigure(name: String): IMDBdatabaseView#FigureRole = {
+    return new FigureRole(name)
+  }
+
+  def createActor(dob: Double, name: String): IMDBdatabaseView#ActorRole = {
+    return new ActorRole(dob, name)
+  }
+
+  def createPerson(dob: Double, name: String): IMDBdatabaseView#PersonRole = {
+    return new PersonRole(dob, name)
+  }
+
+  def createUser(email: String, userName: String, dob: Double, name: String): IMDBdatabaseView#UserRole = {
+    return new UserRole(email, userName, dob, name)
+  }
+
+  def createVote(score: Int): IMDBdatabaseView#VoteRole = {
+    return new VoteRole(score)
+  }
+
+  def createIMDB(): IMDBdatabaseView#IMDBRole = {
+    return new IMDBRole()
+  }
+
+  def createFilm(year: Int, title: String): IMDBdatabaseView#FilmRole = {
+    return new FilmRole(year, title)
+  }
+
+  class IMDBRole extends AViewRole {
+
+    private var users: Set[IMDBdatabaseView#IMDBUsersUserRole] = Set.empty
+    private var votes: Set[IMDBdatabaseView#IMDBVotesVoteRole] = Set.empty
+    private var actors: Set[IMDBdatabaseView#IMDBActorsActorRole] = Set.empty
+    private var films: Set[IMDBdatabaseView#IMDBFilmsFilmRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new IMDB()
+    }
+
+    override def toString(): String = {
+      "VNR: IMDBRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[IMDBdatabaseView] def removeUsersIntern(v: IMDBdatabaseView#IMDBUsersUserRole): Unit = {
+      users -= v
+    }
+
+    private[IMDBdatabaseView] def setUsersIntern(v: IMDBdatabaseView#IMDBUsersUserRole): Unit = {
+      users += v
+    }
+
+    def getUsers(): Set[IMDBdatabaseView#UserRole] = {
+      var vs: Set[IMDBdatabaseView#UserRole] = Set.empty
+      users.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasUsers(v: IMDBdatabaseView#UserRole): Boolean = {
+      return getUsers.contains(v)
+    }
+
+    def addUsers(v: IMDBdatabaseView#UserRole): Boolean = {
+      if (hasUsers(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new IMDBUsersUserRole(this, v)
+      return true
+    }
+
+    def removeUsers(v: IMDBdatabaseView#UserRole): Boolean = {
+      if (!hasUsers(v)) return false
+      users.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeVotesIntern(v: IMDBdatabaseView#IMDBVotesVoteRole): Unit = {
+      votes -= v
+    }
+
+    private[IMDBdatabaseView] def setVotesIntern(v: IMDBdatabaseView#IMDBVotesVoteRole): Unit = {
+      votes += v
+    }
+
+    def getVotes(): Set[IMDBdatabaseView#VoteRole] = {
+      var vs: Set[IMDBdatabaseView#VoteRole] = Set.empty
+      votes.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasVotes(v: IMDBdatabaseView#VoteRole): Boolean = {
+      return getVotes.contains(v)
+    }
+
+    def addVotes(v: IMDBdatabaseView#VoteRole): Boolean = {
+      if (hasVotes(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new IMDBVotesVoteRole(this, v)
+      return true
+    }
+
+    def removeVotes(v: IMDBdatabaseView#VoteRole): Boolean = {
+      if (!hasVotes(v)) return false
+      votes.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeActorsIntern(v: IMDBdatabaseView#IMDBActorsActorRole): Unit = {
+      actors -= v
+    }
+
+    private[IMDBdatabaseView] def setActorsIntern(v: IMDBdatabaseView#IMDBActorsActorRole): Unit = {
+      actors += v
+    }
+
+    def getActors(): Set[IMDBdatabaseView#ActorRole] = {
+      var vs: Set[IMDBdatabaseView#ActorRole] = Set.empty
+      actors.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasActors(v: IMDBdatabaseView#ActorRole): Boolean = {
+      return getActors.contains(v)
+    }
+
+    def addActors(v: IMDBdatabaseView#ActorRole): Boolean = {
+      if (hasActors(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new IMDBActorsActorRole(this, v)
+      return true
+    }
+
+    def removeActors(v: IMDBdatabaseView#ActorRole): Boolean = {
+      if (!hasActors(v)) return false
+      actors.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeFilmsIntern(v: IMDBdatabaseView#IMDBFilmsFilmRole): Unit = {
+      films -= v
+    }
+
+    private[IMDBdatabaseView] def setFilmsIntern(v: IMDBdatabaseView#IMDBFilmsFilmRole): Unit = {
+      films += v
+    }
+
+    def getFilms(): Set[IMDBdatabaseView#FilmRole] = {
+      var vs: Set[IMDBdatabaseView#FilmRole] = Set.empty
+      films.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasFilms(v: IMDBdatabaseView#FilmRole): Boolean = {
+      return getFilms.contains(v)
+    }
+
+    def addFilms(v: IMDBdatabaseView#FilmRole): Boolean = {
+      if (hasFilms(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new IMDBFilmsFilmRole(this, v)
+      return true
+    }
+
+    def removeFilms(v: IMDBdatabaseView#FilmRole): Boolean = {
+      if (!hasFilms(v)) return false
+      films.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class FilmRole(protected val year: Int, protected val title: String) extends AViewRole {
+
+    private var library: IMDBdatabaseView#IMDBFilmsFilmRole = null
+    private var votes: Set[IMDBdatabaseView#VoteFilmFilmRole] = Set.empty
+    private var figures: Set[IMDBdatabaseView#FilmFiguresFigureRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Film(year, title)
+    }
+
+    override def toString(): String = {
+      "VNR: FilmRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getYearView(): Int = {
+      +this getYear ()
+    }
+
+    def setYearView(year: Int): Unit = {
+      +this setYear (year)
+      +this changeSomething ()
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String): Unit = {
+      +this setTitle (title)
+      +this changeSomething ()
+    }
+
+    private[IMDBdatabaseView] def removeLibraryIntern(v: IMDBdatabaseView#IMDBFilmsFilmRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseView] def setLibraryIntern(v: IMDBdatabaseView#IMDBFilmsFilmRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseView#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseView#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBFilmsFilmRole(v, this)
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeVotesIntern(v: IMDBdatabaseView#VoteFilmFilmRole): Unit = {
+      votes -= v
+    }
+
+    private[IMDBdatabaseView] def setVotesIntern(v: IMDBdatabaseView#VoteFilmFilmRole): Unit = {
+      votes += v
+    }
+
+    def getVotes(): Set[IMDBdatabaseView#VoteRole] = {
+      var vs: Set[IMDBdatabaseView#VoteRole] = Set.empty
+      votes.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasVotes(v: IMDBdatabaseView#VoteRole): Boolean = {
+      return getVotes.contains(v)
+    }
+
+    def addVotes(v: IMDBdatabaseView#VoteRole): Boolean = {
+      if (hasVotes(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new VoteFilmFilmRole(v, this)
+      return true
+    }
+
+    def removeVotes(v: IMDBdatabaseView#VoteRole): Boolean = {
+      if (!hasVotes(v)) return false
+      votes.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeFiguresIntern(v: IMDBdatabaseView#FilmFiguresFigureRole): Unit = {
+      figures -= v
+    }
+
+    private[IMDBdatabaseView] def setFiguresIntern(v: IMDBdatabaseView#FilmFiguresFigureRole): Unit = {
+      figures += v
+    }
+
+    def getFigures(): Set[IMDBdatabaseView#FigureRole] = {
+      var vs: Set[IMDBdatabaseView#FigureRole] = Set.empty
+      figures.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasFigures(v: IMDBdatabaseView#FigureRole): Boolean = {
+      return getFigures.contains(v)
+    }
+
+    def addFigures(v: IMDBdatabaseView#FigureRole): Boolean = {
+      if (hasFigures(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new FilmFiguresFigureRole(this, v)
+      return true
+    }
+
+    def removeFigures(v: IMDBdatabaseView#FigureRole): Boolean = {
+      if (!hasFigures(v)) return false
+      figures.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class VoteRole(protected val score: Int) extends AViewRole {
+
+    private var user: IMDBdatabaseView#VoteUserUserRole = null
+    private var library: IMDBdatabaseView#IMDBVotesVoteRole = null
+    private var film: IMDBdatabaseView#VoteFilmFilmRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Vote(score)
+    }
+
+    override def toString(): String = {
+      "VNR: VoteRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getScoreView(): Int = {
+      +this getScore ()
+    }
+
+    def setScoreView(score: Int): Unit = {
+      +this setScore (score)
+      +this changeSomething ()
+    }
+
+    private[IMDBdatabaseView] def removeUserIntern(v: IMDBdatabaseView#VoteUserUserRole): Unit = {
+      user = null
+    }
+
+    private[IMDBdatabaseView] def setUserIntern(v: IMDBdatabaseView#VoteUserUserRole): Unit = {
+      user = v
+    }
+
+    def getUser(): IMDBdatabaseView#UserRole = {
+      return user.getTarget()
+    }
+
+    def setUser(v: IMDBdatabaseView#UserRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (user != null) {
+        if (user.getTarget() == v) return false
+        user.deleteElement()
+      }
+      new VoteUserUserRole(this, v)
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeLibraryIntern(v: IMDBdatabaseView#IMDBVotesVoteRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseView] def setLibraryIntern(v: IMDBdatabaseView#IMDBVotesVoteRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseView#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseView#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBVotesVoteRole(v, this)
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeFilmIntern(v: IMDBdatabaseView#VoteFilmFilmRole): Unit = {
+      film = null
+    }
+
+    private[IMDBdatabaseView] def setFilmIntern(v: IMDBdatabaseView#VoteFilmFilmRole): Unit = {
+      film = v
+    }
+
+    def getFilm(): IMDBdatabaseView#FilmRole = {
+      return film.getTarget()
+    }
+
+    def setFilm(v: IMDBdatabaseView#FilmRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (film != null) {
+        if (film.getTarget() == v) return false
+        film.deleteElement()
+      }
+      new VoteFilmFilmRole(this, v)
+      return true
+    }
+
+  }
+
+  class ActorRole(p_Dob: Double, p_Name: String) extends PersonRole(p_Dob, p_Name) {
+
+    private var plays: Set[IMDBdatabaseView#FigurePlayedByActorRole] = Set.empty
+    private var library: IMDBdatabaseView#IMDBActorsActorRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Actor(dob, name)
+    }
+
+    override def toString(): String = {
+      "VNR: ActorRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    private[IMDBdatabaseView] def removePlaysIntern(v: IMDBdatabaseView#FigurePlayedByActorRole): Unit = {
+      plays -= v
+    }
+
+    private[IMDBdatabaseView] def setPlaysIntern(v: IMDBdatabaseView#FigurePlayedByActorRole): Unit = {
+      plays += v
+    }
+
+    def getPlays(): Set[IMDBdatabaseView#FigureRole] = {
+      var vs: Set[IMDBdatabaseView#FigureRole] = Set.empty
+      plays.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasPlays(v: IMDBdatabaseView#FigureRole): Boolean = {
+      return getPlays.contains(v)
+    }
+
+    def addPlays(v: IMDBdatabaseView#FigureRole): Boolean = {
+      if (hasPlays(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new FigurePlayedByActorRole(v, this)
+      return true
+    }
+
+    def removePlays(v: IMDBdatabaseView#FigureRole): Boolean = {
+      if (!hasPlays(v)) return false
+      plays.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeLibraryIntern(v: IMDBdatabaseView#IMDBActorsActorRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseView] def setLibraryIntern(v: IMDBdatabaseView#IMDBActorsActorRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseView#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseView#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBActorsActorRole(v, this)
+      return true
+    }
+
+  }
+
+  class PersonRole(protected val dob: Double, protected val name: String) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Person(dob, name)
+    }
+
+    override def toString(): String = {
+      "VNR: PersonRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getDobView(): Double = {
+      +this getDob ()
+    }
+
+    def setDobView(dob: Double): Unit = {
+      +this setDob (dob)
+      +this changeSomething ()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+  }
+
+  class FigureRole(protected val name: String) extends AViewRole {
+
+    private var playedBy: Set[IMDBdatabaseView#FigurePlayedByActorRole] = Set.empty
+    private var film: IMDBdatabaseView#FilmFiguresFigureRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Figure(name)
+    }
+
+    override def toString(): String = {
+      "VNR: FigureRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+    private[IMDBdatabaseView] def removePlayedByIntern(v: IMDBdatabaseView#FigurePlayedByActorRole): Unit = {
+      playedBy -= v
+    }
+
+    private[IMDBdatabaseView] def setPlayedByIntern(v: IMDBdatabaseView#FigurePlayedByActorRole): Unit = {
+      playedBy += v
+    }
+
+    def getPlayedBy(): Set[IMDBdatabaseView#ActorRole] = {
+      var vs: Set[IMDBdatabaseView#ActorRole] = Set.empty
+      playedBy.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasPlayedBy(v: IMDBdatabaseView#ActorRole): Boolean = {
+      return getPlayedBy.contains(v)
+    }
+
+    def addPlayedBy(v: IMDBdatabaseView#ActorRole): Boolean = {
+      if (hasPlayedBy(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new FigurePlayedByActorRole(this, v)
+      return true
+    }
+
+    def removePlayedBy(v: IMDBdatabaseView#ActorRole): Boolean = {
+      if (!hasPlayedBy(v)) return false
+      playedBy.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[IMDBdatabaseView] def removeFilmIntern(v: IMDBdatabaseView#FilmFiguresFigureRole): Unit = {
+      film = null
+    }
+
+    private[IMDBdatabaseView] def setFilmIntern(v: IMDBdatabaseView#FilmFiguresFigureRole): Unit = {
+      film = v
+    }
+
+    def getFilm(): IMDBdatabaseView#FilmRole = {
+      return film.getSource()
+    }
+
+    def setFilm(v: IMDBdatabaseView#FilmRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (film != null) {
+        if (film.getSource() == v) return false
+        film.deleteElement()
+      }
+      new FilmFiguresFigureRole(v, this)
+      return true
+    }
+
+  }
+
+  class UserRole(protected val email: String, protected val userName: String, p_Dob: Double, p_Name: String) extends PersonRole(p_Dob, p_Name) {
+
+    private var library: IMDBdatabaseView#IMDBUsersUserRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new User(email, userName, dob, name)
+    }
+
+    override def toString(): String = {
+      "VNR: UserRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getEmailView(): String = {
+      +this getEmail ()
+    }
+
+    def setEmailView(email: String): Unit = {
+      +this setEmail (email)
+      +this changeSomething ()
+    }
+
+    def getUserNameView(): String = {
+      +this getUserName ()
+    }
+
+    def setUserNameView(username: String): Unit = {
+      +this setUserName (username)
+      +this changeSomething ()
+    }
+
+    private[IMDBdatabaseView] def removeLibraryIntern(v: IMDBdatabaseView#IMDBUsersUserRole): Unit = {
+      library = null
+    }
+
+    private[IMDBdatabaseView] def setLibraryIntern(v: IMDBdatabaseView#IMDBUsersUserRole): Unit = {
+      library = v
+    }
+
+    def getLibrary(): IMDBdatabaseView#IMDBRole = {
+      return library.getSource()
+    }
+
+    def setLibrary(v: IMDBdatabaseView#IMDBRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (library != null) {
+        if (library.getSource() == v) return false
+        library.deleteElement()
+      }
+      new IMDBUsersUserRole(v, this)
+      return true
+    }
+
+  }
+
+  class FigurePlayedByActorRole(private val source: IMDBdatabaseView#FigureRole, private val target: IMDBdatabaseView#ActorRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setPlaysIntern(this)
+      source.setPlayedByIntern(this)
+      val sp: Figure = getPlayerOfType(source, "Figure").asInstanceOf[Figure]
+      val tp: Actor = getPlayerOfType(target, "Actor").asInstanceOf[Actor]
+      val v: FigurePlayedByActor = new FigurePlayedByActor(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removePlayedByIntern(this)
+      target.removePlaysIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: FigurePlayedByActorRole"
+    }
+
+    def getSource(): IMDBdatabaseView#FigureRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#ActorRole = {
+      target
+    }
+
+  }
+
+  class VoteUserUserRole(private val source: IMDBdatabaseView#VoteRole, private val target: IMDBdatabaseView#UserRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setUserIntern(this)
+      val sp: Vote = getPlayerOfType(source, "Vote").asInstanceOf[Vote]
+      val tp: User = getPlayerOfType(target, "User").asInstanceOf[User]
+      val v: VoteUserUser = new VoteUserUser(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeUserIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: VoteUserUserRole"
+    }
+
+    def getSource(): IMDBdatabaseView#VoteRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#UserRole = {
+      target
+    }
+
+  }
+
+  class IMDBUsersUserRole(private val source: IMDBdatabaseView#IMDBRole, private val target: IMDBdatabaseView#UserRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setUsersIntern(this)
+      val sp: IMDB = getPlayerOfType(source, "IMDB").asInstanceOf[IMDB]
+      val tp: User = getPlayerOfType(target, "User").asInstanceOf[User]
+      val v: IMDBUsersUser = new IMDBUsersUser(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeUsersIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: IMDBUsersUserRole"
+    }
+
+    def getSource(): IMDBdatabaseView#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#UserRole = {
+      target
+    }
+
+  }
+
+  class IMDBVotesVoteRole(private val source: IMDBdatabaseView#IMDBRole, private val target: IMDBdatabaseView#VoteRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setVotesIntern(this)
+      val sp: IMDB = getPlayerOfType(source, "IMDB").asInstanceOf[IMDB]
+      val tp: Vote = getPlayerOfType(target, "Vote").asInstanceOf[Vote]
+      val v: IMDBVotesVote = new IMDBVotesVote(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeVotesIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: IMDBVotesVoteRole"
+    }
+
+    def getSource(): IMDBdatabaseView#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#VoteRole = {
+      target
+    }
+
+  }
+
+  class IMDBActorsActorRole(private val source: IMDBdatabaseView#IMDBRole, private val target: IMDBdatabaseView#ActorRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setActorsIntern(this)
+      val sp: IMDB = getPlayerOfType(source, "IMDB").asInstanceOf[IMDB]
+      val tp: Actor = getPlayerOfType(target, "Actor").asInstanceOf[Actor]
+      val v: IMDBActorsActor = new IMDBActorsActor(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeActorsIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: IMDBActorsActorRole"
+    }
+
+    def getSource(): IMDBdatabaseView#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#ActorRole = {
+      target
+    }
+
+  }
+
+  class IMDBFilmsFilmRole(private val source: IMDBdatabaseView#IMDBRole, private val target: IMDBdatabaseView#FilmRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setLibraryIntern(this)
+      source.setFilmsIntern(this)
+      val sp: IMDB = getPlayerOfType(source, "IMDB").asInstanceOf[IMDB]
+      val tp: Film = getPlayerOfType(target, "Film").asInstanceOf[Film]
+      val v: IMDBFilmsFilm = new IMDBFilmsFilm(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeFilmsIntern(this)
+      target.removeLibraryIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: IMDBFilmsFilmRole"
+    }
+
+    def getSource(): IMDBdatabaseView#IMDBRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#FilmRole = {
+      target
+    }
+
+  }
+
+  class VoteFilmFilmRole(private val source: IMDBdatabaseView#VoteRole, private val target: IMDBdatabaseView#FilmRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setVotesIntern(this)
+      source.setFilmIntern(this)
+      val sp: Vote = getPlayerOfType(source, "Vote").asInstanceOf[Vote]
+      val tp: Film = getPlayerOfType(target, "Film").asInstanceOf[Film]
+      val v: VoteFilmFilm = new VoteFilmFilm(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeFilmIntern(this)
+      target.removeVotesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: VoteFilmFilmRole"
+    }
+
+    def getSource(): IMDBdatabaseView#VoteRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#FilmRole = {
+      target
+    }
+
+  }
+
+  class FilmFiguresFigureRole(private val source: IMDBdatabaseView#FilmRole, private val target: IMDBdatabaseView#FigureRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setFilmIntern(this)
+      source.setFiguresIntern(this)
+      val sp: Film = getPlayerOfType(source, "Film").asInstanceOf[Film]
+      val tp: Figure = getPlayerOfType(target, "Figure").asInstanceOf[Figure]
+      val v: FilmFiguresFigure = new FilmFiguresFigure(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeFiguresIntern(this)
+      target.removeFilmIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: FilmFiguresFigureRole"
+    }
+
+    def getSource(): IMDBdatabaseView#FilmRole = {
+      source
+    }
+
+    def getTarget(): IMDBdatabaseView#FigureRole = {
+      target
+    }
+
+  }
+
+}
+
+object IMDBdatabaseView extends IViewTypeInfo {
+
+  override def getViewName(): String = "IMDBdatabaseView"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set.empty
+
+  protected def getNewInstance(): IViewCompartment = new IMDBdatabaseView()
+
+  def getNewView(): IMDBdatabaseView = getNewViewTypeInstance().asInstanceOf[IMDBdatabaseView]
+}
+      
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/LibrarySimple0.scala b/src/main/scala/view/LibrarySimple0.scala
new file mode 100644
index 0000000000000000000000000000000000000000..424aedaa34536c66f06f440a8e3480317a25f103
--- /dev/null
+++ b/src/main/scala/view/LibrarySimple0.scala
@@ -0,0 +1,209 @@
+package view
+
+import org.rosi_project.model_management.sum.IViewCompartment
+import lib.Library
+import lib.Person
+import lib.LibraryEmployeesEmployee
+import lib.Employee
+
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+class LibrarySimple0 private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[Library] || className.isInstanceOf[Employee] || className.isInstanceOf[LibraryEmployeesEmployee]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    LibrarySimple0.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[Library]) return new LibraryRole(null)
+    if (className.isInstanceOf[Employee]) return new EmployeeRole(0, null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[LibraryEmployeesEmployee]) return new LibraryEmployeesEmployeeRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[EmployeeRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: LibrarySimple0"
+  }
+
+  def createLibrary(name: String): LibrarySimple0#LibraryRole = {
+    return new LibraryRole(name)
+  }
+
+  def createEmployee(salary: Double, name: String): LibrarySimple0#EmployeeRole = {
+    return new EmployeeRole(salary, name)
+  }
+
+  class LibraryRole(protected val name: String) extends AViewRole {
+
+    private var employees: Set[LibrarySimple0#LibraryEmployeesEmployeeRole] = Set.empty
+
+    private[LibrarySimple0] def removeEmployeesIntern(v: LibrarySimple0#LibraryEmployeesEmployeeRole): Unit = {
+      employees -= v
+    }
+
+    private[LibrarySimple0] def setEmployeesIntern(v: LibrarySimple0#LibraryEmployeesEmployeeRole): Unit = {
+      employees += v
+    }
+
+    def getEmployees(): Set[LibrarySimple0#EmployeeRole] = {
+      var vs: Set[LibrarySimple0#EmployeeRole] = Set.empty
+      employees.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasEmployees(v: LibrarySimple0#EmployeeRole): Boolean = {
+      return getEmployees.contains(v)
+    }
+
+    def addEmployees(v: LibrarySimple0#EmployeeRole): Boolean = {
+      if (hasEmployees(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryEmployeesEmployeeRole(this, v)
+      return true
+    }
+
+    def removeEmployees(v: LibrarySimple0#EmployeeRole): Boolean = {
+      if (!hasEmployees(v)) return false
+      employees.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Library(name)
+    }
+
+    override def toString(): String = {
+      "VNR: LibraryRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+  }
+
+  class EmployeeRole(protected val salary: Double, p_Name: String) extends PersonRole(p_Name) {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Employee(salary, name)
+    }
+
+    override def toString(): String = {
+      "VNR: EmployeeRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getSalaryView(): Double = {
+      +this getSalary ()
+    }
+
+    def setSalaryView(salary: Double): Unit = {
+      +this setSalary (salary)
+      +this changeSomething ()
+    }
+
+  }
+
+  abstract class PersonRole(protected val name: String) extends AViewRole {
+
+    override def toString(): String = {
+      "VNR: PersonRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+  }
+
+  class LibraryEmployeesEmployeeRole(private val source: LibrarySimple0#LibraryRole, private val target: LibrarySimple0#EmployeeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setEmployeesIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Employee = getPlayerOfType(target, "Employee").asInstanceOf[Employee]
+      val v: LibraryEmployeesEmployee = new LibraryEmployeesEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeEmployeesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryEmployeesEmployeeRole"
+    }
+
+    def getSource(): LibrarySimple0#LibraryRole = {
+      source
+    }
+
+    def getTarget(): LibrarySimple0#EmployeeRole = {
+      target
+    }
+
+  }
+
+}
+
+object LibrarySimple0 extends IViewTypeInfo {
+
+  override def getViewName(): String = "LibrarySimple0"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set.empty
+
+  protected def getNewInstance(): IViewCompartment = new LibrarySimple0()
+
+  def getNewView(): LibrarySimple0 = getNewViewTypeInstance().asInstanceOf[LibrarySimple0]
+}
+      
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/LibraryView.scala b/src/main/scala/view/LibraryView.scala
new file mode 100644
index 0000000000000000000000000000000000000000..eb968bea61ae73731e8561601eaa0dd6db583ce8
--- /dev/null
+++ b/src/main/scala/view/LibraryView.scala
@@ -0,0 +1,269 @@
+package view
+
+import org.rosi_project.model_management.sum.IViewCompartment
+import lib.EmployeeManagerEmployee
+import lib.Library
+import lib.Person
+import lib.LibraryEmployeesEmployee
+import lib.Employee
+
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+class LibraryView private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[EmployeeManagerEmployee] || className.isInstanceOf[LibraryEmployeesEmployee] || className.isInstanceOf[Library] || className.isInstanceOf[Employee]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    LibraryView.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[Library]) return new LibraryRole(null)
+    if (className.isInstanceOf[Employee]) return new EmployeeRole(0, null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[LibraryEmployeesEmployee]) return new LibraryEmployeesEmployeeRole(sourceRole.asInstanceOf[LibraryRole], targetRole.asInstanceOf[EmployeeRole])
+    if (className.isInstanceOf[EmployeeManagerEmployee]) return new EmployeeManagerEmployeeRole(sourceRole.asInstanceOf[EmployeeRole], targetRole.asInstanceOf[EmployeeRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: LibraryView"
+  }
+
+  def createLibrary(name: String): LibraryView#LibraryRole = {
+    return new LibraryRole(name)
+  }
+
+  def createEmployee(salary: Double, name: String): LibraryView#EmployeeRole = {
+    return new EmployeeRole(salary, name)
+  }
+
+  class LibraryRole(protected val name: String) extends AViewRole {
+
+    private var employees: Set[LibraryView#LibraryEmployeesEmployeeRole] = Set.empty
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Library(name)
+    }
+
+    override def toString(): String = {
+      "VNR: LibraryRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+    private[LibraryView] def removeEmployeesIntern(v: LibraryView#LibraryEmployeesEmployeeRole): Unit = {
+      employees -= v
+    }
+
+    private[LibraryView] def setEmployeesIntern(v: LibraryView#LibraryEmployeesEmployeeRole): Unit = {
+      employees += v
+    }
+
+    def getEmployees(): Set[LibraryView#EmployeeRole] = {
+      var vs: Set[LibraryView#EmployeeRole] = Set.empty
+      employees.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasEmployees(v: LibraryView#EmployeeRole): Boolean = {
+      return getEmployees.contains(v)
+    }
+
+    def addEmployees(v: LibraryView#EmployeeRole): Boolean = {
+      if (hasEmployees(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new LibraryEmployeesEmployeeRole(this, v)
+      return true
+    }
+
+    def removeEmployees(v: LibraryView#EmployeeRole): Boolean = {
+      if (!hasEmployees(v)) return false
+      employees.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+  }
+
+  class EmployeeRole(protected val salary: Double, p_Name: String) extends PersonRole(p_Name) {
+
+    private var manager: LibraryView#EmployeeManagerEmployeeRole = null
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Employee(salary, name)
+    }
+
+    override def toString(): String = {
+      "VNR: EmployeeRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getSalaryView(): Double = {
+      +this getSalary ()
+    }
+
+    def setSalaryView(salary: Double): Unit = {
+      +this setSalary (salary)
+      +this changeSomething ()
+    }
+
+    private[LibraryView] def removeManagerIntern(v: LibraryView#EmployeeManagerEmployeeRole): Unit = {
+      manager = null
+    }
+
+    private[LibraryView] def setManagerIntern(v: LibraryView#EmployeeManagerEmployeeRole): Unit = {
+      manager = v
+    }
+
+    def getManager(): LibraryView#EmployeeRole = {
+      return manager.getTarget()
+    }
+
+    def setManager(v: LibraryView#EmployeeRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (manager != null) {
+        if (manager.getTarget() == v) return false
+        manager.deleteElement()
+      }
+      new EmployeeManagerEmployeeRole(this, v)
+      return true
+    }
+
+  }
+
+  abstract class PersonRole(protected val name: String) extends AViewRole {
+
+    override def toString(): String = {
+      "VNR: PersonRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+  }
+
+  class LibraryEmployeesEmployeeRole(private val source: LibraryView#LibraryRole, private val target: LibraryView#EmployeeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setEmployeesIntern(this)
+      val sp: Library = getPlayerOfType(source, "Library").asInstanceOf[Library]
+      val tp: Employee = getPlayerOfType(target, "Employee").asInstanceOf[Employee]
+      val v: LibraryEmployeesEmployee = new LibraryEmployeesEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeEmployeesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: LibraryEmployeesEmployeeRole"
+    }
+
+    def getSource(): LibraryView#LibraryRole = {
+      source
+    }
+
+    def getTarget(): LibraryView#EmployeeRole = {
+      target
+    }
+
+  }
+
+  class EmployeeManagerEmployeeRole(private val source: LibraryView#EmployeeRole, private val target: LibraryView#EmployeeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setManagerIntern(this)
+      val sp: Employee = getPlayerOfType(source, "Employee").asInstanceOf[Employee]
+      val tp: Employee = getPlayerOfType(target, "Employee").asInstanceOf[Employee]
+      val v: EmployeeManagerEmployee = new EmployeeManagerEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeManagerIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: EmployeeManagerEmployeeRole"
+    }
+
+    def getSource(): LibraryView#EmployeeRole = {
+      source
+    }
+
+    def getTarget(): LibraryView#EmployeeRole = {
+      target
+    }
+
+  }
+
+}
+
+object LibraryView extends IViewTypeInfo {
+
+  override def getViewName(): String = "LibraryView"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set.empty
+
+  protected def getNewInstance(): IViewCompartment = new LibraryView()
+
+  def getNewView(): LibraryView = getNewViewTypeInstance().asInstanceOf[LibraryView]
+}
+      
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/Manager0.scala b/src/main/scala/view/Manager0.scala
new file mode 100644
index 0000000000000000000000000000000000000000..8aa7d135fb1dc9c4767489cc83bb0f465ce02a83
--- /dev/null
+++ b/src/main/scala/view/Manager0.scala
@@ -0,0 +1,162 @@
+package view
+
+import org.rosi_project.model_management.sum.IViewCompartment
+import lib.Employee
+import lib.EmployeeManagerEmployee
+import lib.Person
+
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+
+class Manager0 private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[Employee] || className.isInstanceOf[EmployeeManagerEmployee]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    Manager0.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[Employee]) return new EmployeeRole(0, null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[EmployeeManagerEmployee]) return new EmployeeManagerEmployeeRole(sourceRole.asInstanceOf[EmployeeRole], targetRole.asInstanceOf[EmployeeRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: Manager0"
+  }
+
+  def createEmployee(salary: Double, name: String): Manager0#EmployeeRole = {
+    return new EmployeeRole(salary, name)
+  }
+
+  class EmployeeRole(protected val salary: Double, p_Name: String) extends PersonRole(p_Name) {
+
+    private var manager: Manager0#EmployeeManagerEmployeeRole = null
+
+    private[Manager0] def removeManagerIntern(v: Manager0#EmployeeManagerEmployeeRole): Unit = {
+      manager = null
+    }
+
+    private[Manager0] def setManagerIntern(v: Manager0#EmployeeManagerEmployeeRole): Unit = {
+      manager = v
+    }
+
+    def getManager(): Manager0#EmployeeRole = {
+      return manager.getTarget()
+    }
+
+    def setManager(v: Manager0#EmployeeRole): Boolean = {
+      if (v == null) return false
+      if (!containsRole(v.asInstanceOf[AViewRole])) return false
+      if (manager != null) {
+        if (manager.getTarget() == v) return false
+        manager.deleteElement()
+      }
+      new EmployeeManagerEmployeeRole(this, v)
+      return true
+    }
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Employee(salary, name)
+    }
+
+    override def toString(): String = {
+      "VNR: EmployeeRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getSalaryView(): Double = {
+      +this getSalary ()
+    }
+
+    def setSalaryView(salary: Double): Unit = {
+      +this setSalary (salary)
+      +this changeSomething ()
+    }
+
+  }
+
+  abstract class PersonRole(protected val name: String) extends AViewRole {
+
+    override def toString(): String = {
+      "VNR: PersonRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getNameView(): String = {
+      +this getName ()
+    }
+
+    def setNameView(name: String): Unit = {
+      +this setName (name)
+      +this changeSomething ()
+    }
+
+  }
+
+  class EmployeeManagerEmployeeRole(private val source: Manager0#EmployeeRole, private val target: Manager0#EmployeeRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setManagerIntern(this)
+      val sp: Employee = getPlayerOfType(source, "Employee").asInstanceOf[Employee]
+      val tp: Employee = getPlayerOfType(target, "Employee").asInstanceOf[Employee]
+      val v: EmployeeManagerEmployee = new EmployeeManagerEmployee(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeManagerIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: EmployeeManagerEmployeeRole"
+    }
+
+    def getSource(): Manager0#EmployeeRole = {
+      source
+    }
+
+    def getTarget(): Manager0#EmployeeRole = {
+      target
+    }
+
+  }
+
+}
+
+object Manager0 extends IViewTypeInfo {
+
+  override def getViewName(): String = "Manager0"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set.empty
+
+  protected def getNewInstance(): IViewCompartment = new Manager0()
+
+  def getNewView(): Manager0 = getNewViewTypeInstance().asInstanceOf[Manager0]
+}
+      
+
+    
\ No newline at end of file
diff --git a/src/main/scala/view/Simple0.scala b/src/main/scala/view/Simple0.scala
new file mode 100644
index 0000000000000000000000000000000000000000..abce9512c93b05a294402826af22d58608018de9
--- /dev/null
+++ b/src/main/scala/view/Simple0.scala
@@ -0,0 +1,314 @@
+package view
+
+import org.rosi_project.model_management.sum.IViewCompartment
+import imdbdatabase.VoteFilmFilm
+import imdbdatabase.Film
+import elib.VideoCassette
+import joins.JoinMovie
+import elib.Person
+import elib.VideoCassetteCastPerson
+import imdbdatabase.Vote
+
+import org.rosi_project.model_management.sum.IViewTypeInfo
+import org.rosi_project.model_management.sum.join.IJoinInfo
+import joins.JoinMovieObject
+
+class Simple0 private extends IViewCompartment {
+
+  protected def isViewable(className: Object): Boolean = {
+    if (className.isInstanceOf[Person] || className.isInstanceOf[Vote] || className.isInstanceOf[JoinMovie] || className.isInstanceOf[VoteFilmFilm] || className.isInstanceOf[VideoCassetteCastPerson]) return true
+    return false
+  }
+
+  def getViewName(): String = {
+    Simple0.getViewName()
+  }
+
+  protected def getNaturalRole(className: Object): AViewRole = {
+    if (className.isInstanceOf[JoinMovie]) return new JoinMovieRole(null, 0, 0)
+    if (className.isInstanceOf[Vote]) return new VoteRole(0)
+    if (className.isInstanceOf[Person]) return new PersonRole(null)
+    return null
+  }
+
+  protected def getRelationalRole(className: Object, sourceRole: AViewRole, targetRole: AViewRole): AViewRole = {
+    if (className.isInstanceOf[VoteFilmFilm]) return new VoteFilmFilmRole(sourceRole.asInstanceOf[VoteRole], targetRole.asInstanceOf[JoinMovieRole])
+    if (className.isInstanceOf[VideoCassetteCastPerson]) return new VideoCassetteCastPersonRole(sourceRole.asInstanceOf[JoinMovieRole], targetRole.asInstanceOf[PersonRole])
+    return null
+  }
+
+  override def toString(): String = {
+    "VC: Simple0"
+  }
+
+  def createJoinMovie(title: String, year: Int, minutesLength: Int): Simple0#JoinMovieRole = {
+    return new JoinMovieRole(title, year, minutesLength)
+  }
+
+  def createVote(score: Int): Simple0#VoteRole = {
+    return new VoteRole(score)
+  }
+
+  def createPerson(lastName: String): Simple0#PersonRole = {
+    return new PersonRole(lastName)
+  }
+
+  class JoinMovieRole(protected val title: String, protected val year: Int, protected val minutesLength: Int) extends AViewRole {
+
+    private var votes: Set[Simple0#VoteFilmFilmRole] = Set.empty
+    private var cast: Set[Simple0#VideoCassetteCastPersonRole] = Set.empty
+
+    private[Simple0] def removeVotesIntern(v: Simple0#VoteFilmFilmRole): Unit = {
+      votes -= v
+    }
+
+    private[Simple0] def setVotesIntern(v: Simple0#VoteFilmFilmRole): Unit = {
+      votes += v
+    }
+
+    def getVotes(): Set[Simple0#VoteRole] = {
+      var vs: Set[Simple0#VoteRole] = Set.empty
+      votes.foreach { v => vs += v.getSource() }
+      return vs
+    }
+
+    def hasVotes(v: Simple0#VoteRole): Boolean = {
+      return getVotes.contains(v)
+    }
+
+    def addVotes(v: Simple0#VoteRole): Boolean = {
+      if (hasVotes(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new VoteFilmFilmRole(v, this)
+      return true
+    }
+
+    def removeVotes(v: Simple0#VoteRole): Boolean = {
+      if (!hasVotes(v)) return false
+      votes.foreach { h =>
+        if (h.getSource() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    private[Simple0] def removeCastIntern(v: Simple0#VideoCassetteCastPersonRole): Unit = {
+      cast -= v
+    }
+
+    private[Simple0] def setCastIntern(v: Simple0#VideoCassetteCastPersonRole): Unit = {
+      cast += v
+    }
+
+    def getCast(): Set[Simple0#PersonRole] = {
+      var vs: Set[Simple0#PersonRole] = Set.empty
+      cast.foreach { v => vs += v.getTarget() }
+      return vs
+    }
+
+    def hasCast(v: Simple0#PersonRole): Boolean = {
+      return getCast.contains(v)
+    }
+
+    def addCast(v: Simple0#PersonRole): Boolean = {
+      if (hasCast(v) || !containsRole(v.asInstanceOf[AViewRole])) return false
+      new VideoCassetteCastPersonRole(this, v)
+      return true
+    }
+
+    def removeCast(v: Simple0#PersonRole): Boolean = {
+      if (!hasCast(v)) return false
+      cast.foreach { h =>
+        if (h.getTarget() == v) {
+          h.deleteElement()
+          return true
+        }
+      }
+      return true
+    }
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new JoinMovie(new Film(year, title), new VideoCassette(false, minutesLength, title, null))
+    }
+
+    override def toString(): String = {
+      "VNR: JoinMovieRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getTitleView(): String = {
+      +this getTitle ()
+    }
+
+    def setTitleView(title: String): Unit = {
+      +this setTitle (title)
+      +this changeSomething ()
+    }
+
+    def getYearView(): Int = {
+      +this getYear ()
+    }
+
+    def setYearView(year: Int): Unit = {
+      +this setYear (year)
+      +this changeSomething ()
+    }
+
+    def getMinutesLengthView(): Int = {
+      +this getMinutesLength ()
+    }
+
+    def setMinutesLengthView(minuteslength: Int): Unit = {
+      +this setMinutesLength (minuteslength)
+      +this changeSomething ()
+    }
+
+  }
+
+  class VoteRole(protected val score: Int) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Vote(score)
+    }
+
+    override def toString(): String = {
+      "VNR: VoteRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getScoreView(): Int = {
+      +this getScore ()
+    }
+
+    def setScoreView(score: Int): Unit = {
+      +this setScore (score)
+      +this changeSomething ()
+    }
+
+  }
+
+  class VoteFilmFilmRole(private val source: Simple0#VoteRole, private val target: Simple0#JoinMovieRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      target.setVotesIntern(this)
+      val sp: Vote = getPlayerOfType(source, "Vote").asInstanceOf[Vote]
+      val tp: Film = getPlayerOfType(target, "Film").asInstanceOf[Film]
+      val v: VoteFilmFilm = new VoteFilmFilm(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      target.removeVotesIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: VoteFilmFilmRole"
+    }
+
+    def getSource(): Simple0#VoteRole = {
+      source
+    }
+
+    def getTarget(): Simple0#JoinMovieRole = {
+      target
+    }
+
+  }
+
+  class PersonRole(protected val lastName: String) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return false
+    }
+
+    override protected def getCreationObject(): Object = {
+      return new Person(lastName, null)
+    }
+
+    override def toString(): String = {
+      "VNR: PersonRole"
+    }
+
+    override def deleteElement(): Unit = {
+      super.deleteElement()
+    }
+
+    def getLastNameView(): String = {
+      +this getLastName ()
+    }
+
+    def setLastNameView(lastname: String): Unit = {
+      +this setLastName (lastname)
+      +this changeSomething ()
+    }
+
+  }
+
+  class VideoCassetteCastPersonRole(private val source: Simple0#JoinMovieRole, private val target: Simple0#PersonRole) extends AViewRole {
+
+    override protected def isRelational(): Boolean = {
+      return true
+    }
+
+    override protected def getCreationObject(): Object = {
+      source.setCastIntern(this)
+      val sp: VideoCassette = getPlayerOfType(source, "VideoCassette").asInstanceOf[VideoCassette]
+      val tp: Person = getPlayerOfType(target, "Person").asInstanceOf[Person]
+      val v: VideoCassetteCastPerson = new VideoCassetteCastPerson(sp, tp)
+      return v
+    }
+
+    override def deleteElement(): Unit = {
+      source.removeCastIntern(this)
+      super.deleteElement()
+    }
+
+    override def toString(): String = {
+      "VRR: VideoCassetteCastPersonRole"
+    }
+
+    def getSource(): Simple0#JoinMovieRole = {
+      source
+    }
+
+    def getTarget(): Simple0#PersonRole = {
+      target
+    }
+
+  }
+
+}
+
+object Simple0 extends IViewTypeInfo {
+
+  override def getViewName(): String = "Simple0"
+
+  def getJoinInfos(): Set[IJoinInfo] = Set(JoinMovieObject)
+
+  protected def getNewInstance(): IViewCompartment = new Simple0()
+
+  def getNewView(): Simple0 = getNewViewTypeInstance().asInstanceOf[Simple0]
+}
+      
+
+    
\ No newline at end of file
diff --git a/support/scalastyle_config.xml b/support/scalastyle_config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a34869af642490a57ae2850a4749789aa5d6c2bb
--- /dev/null
+++ b/support/scalastyle_config.xml
@@ -0,0 +1,188 @@
+<scalastyle commentFilter="enabled">
+ <name>Scalastyle standard configuration</name>
+ <check class="org.scalastyle.file.FileTabChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.file.FileLengthChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maxFileLength"><![CDATA[800]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.file.HeaderMatchesChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="header"><![CDATA[// Copyright (C) 2011-2012 the original author or authors.
+// See the LICENCE.txt file distributed with this work for additional
+// information regarding copyright ownership.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.SpacesAfterPlusChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.file.WhitespaceEndOfLineChecker" level="warning" enabled="true">
+   <parameters>
+    <parameter name="ignoreWhitespaceLines"><![CDATA[false]]></parameter>
+   </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.SpacesBeforePlusChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.file.FileLineLengthChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maxLineLength"><![CDATA[160]]></parameter>
+   <parameter name="tabSize"><![CDATA[4]]></parameter>
+   <parameter name="ignoreImports"><![CDATA[false]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.ClassNamesChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="regex"><![CDATA[^[A-Z][A-Za-z]*$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.ObjectNamesChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="regex"><![CDATA[^[A-Z][A-Za-z]*$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.PackageObjectNamesChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="regex"><![CDATA[^[a-z][A-Za-z]*$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.EqualsHashCodeChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.IllegalImportsChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="illegalImports"><![CDATA[sun._,java.awt._]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.ParameterNumberChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maxParameters"><![CDATA[8]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.MagicNumberChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="ignore"><![CDATA[-1,0,1,2,3]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.NoWhitespaceBeforeLeftBracketChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.NoWhitespaceAfterLeftBracketChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.ReturnChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.NullChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.NoCloneChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.NoFinalizeChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.CovariantEqualsChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.StructuralTypeChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.file.RegexChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="regex"><![CDATA[println]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.NumberOfTypesChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maxTypes"><![CDATA[30]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.CyclomaticComplexityChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maximum"><![CDATA[10]]></parameter>
+   <parameter name="countCases"><![CDATA[true]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.UppercaseLChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.SimplifyBooleanExpressionChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.IfBraceChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="singleLineAllowed"><![CDATA[true]]></parameter>
+   <parameter name="doubleLineAllowed"><![CDATA[false]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.MethodLengthChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maxLength"><![CDATA[50]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.MethodNamesChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="regex"><![CDATA[^[a-z][A-Za-z0-9]*(_=)?$]]></parameter>
+   <parameter name="ignoreRegex"><![CDATA[^$]]></parameter>
+   <parameter name="ignoreOverride"><![CDATA[false]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.NumberOfMethodsInTypeChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="maxMethods"><![CDATA[30]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.PublicMethodsHaveTypeChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="ignoreOverride"><![CDATA[false]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.file.NewLineAtEofChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.file.NoNewLineAtEofChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.WhileChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.VarFieldChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.VarLocalChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.RedundantIfChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.TokenChecker" level="warning" enabled="false">
+  <parameters>
+   <parameter name="regex"><![CDATA[println]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.DeprecatedJavaChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.OverrideJavaChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.EmptyClassChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.ClassTypeParameterChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="regex"><![CDATA[^[A-Z_]$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.UnderscoreImportChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.LowercasePatternMatchChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.EmptyInterpolatedStringChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.MultipleStringLiteralsChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="allowed"><![CDATA[2]]></parameter>
+   <parameter name="ignoreRegex"><![CDATA[^""$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.ImportGroupingChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.NotImplementedErrorUsage" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.BlockImportChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.ProcedureDeclarationChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.ForBraceChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.ForLoopChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.SpaceAfterCommentStartChecker" level="warning" enabled="true"></check>
+ <check class="org.scalastyle.scalariform.ScalaDocChecker" level="warning" enabled="false">
+  <parameters>
+   <parameter name="ignoreRegex"><![CDATA[^$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.DisallowSpaceAfterTokenChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.DisallowSpaceBeforeTokenChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.EnsureSingleSpaceAfterTokenChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.EnsureSingleSpaceBeforeTokenChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.scalariform.NonASCIICharacterChecker" level="warning" enabled="false"></check>
+ <check class="org.scalastyle.file.IndentationChecker" level="warning" enabled="false">
+  <parameters>
+   <parameter name="tabSize"><![CDATA[2]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.FieldNamesChecker" level="warning" enabled="false">
+  <parameters>
+   <parameter name="regex"><![CDATA[^[a-z][A-Za-z]*$]]></parameter>
+   <parameter name="objectFieldRegex"><![CDATA[^[A-Z][A-Za-z]*$]]></parameter>
+  </parameters>
+ </check>
+ <check class="org.scalastyle.scalariform.TodoCommentChecker" level="warning" enabled="true">
+  <parameters>
+   <parameter name="words"><![CDATA[TODO|FIXME]]></parameter>
+  </parameters>
+ </check>
+</scalastyle>