Add final stuff for SUM EMF Load models

src/main/scala/org/rosi_project/model_sync/generator/acr_model/ComplexSModel.scala

@@ -7,7 +7,7 @@ import org.rosi_project.model_sync.generator.support.Assert
  *
  * @author Christopher Werner
  */
-class ComplexSModel(name: String, sourceName: String) extends SModel(name, sourceName) {
+class ComplexSModel(name: String, sourceName: String, nsUri: String) extends SModel(name, sourceName, nsUri) {
 
   private var modelClasses: Set[SClass] = Set.empty
   private var providerClasses: Set[SClass] = Set.empty

src/main/scala/org/rosi_project/model_sync/generator/acr_model/SModel.scala

@@ -5,7 +5,10 @@ package org.rosi_project.model_sync.generator.acr_model
   *
   * @author Rico Bergmann
   */
-abstract class SModel(private val name: String, private val sourceName: String) extends SModelElement {
+abstract class SModel(private val name: String, private val sourceName: String, private val nsUri: String) extends SModelElement {
+  
+  /** Get NsURI from the model. */
+  def getNsURI: String = nsUri
   
   /** Get source name from the model. */
   def getSourceName: String = sourceName

src/main/scala/org/rosi_project/model_sync/generator/acr_model/SimpleSModel.scala

@@ -6,7 +6,7 @@ import org.rosi_project.model_sync.generator.support.Assert
   *
   * @author Rico Bergmann
   */
-class SimpleSModel(name: String, sourceName: String) extends SModel(name, sourceName) {
+class SimpleSModel(name: String, sourceName: String, nsUri: String) extends SModel(name, sourceName, nsUri) {
   
   private var sClasses: Set[SClass] = Set.empty
   private var sEnums: Set[SEnum] = Set.empty

src/main/scala/org/rosi_project/model_sync/generator/acr_model/types/PredefEcoreTypes.scala

@@ -11,6 +11,15 @@ import org.rosi_project.model_sync.generator.acr_model.SType
   */
 object PredefEcoreTypes {
   
+  /**  `org.eclipse.emf.common.util.URI` */
+  val URI = SType("URI", "org.eclipse.emf.common.util")
+  
+  /**  `org.eclipse.emf.ecore.resource.Resource` */
+  val Resource = SType("Resource", "org.eclipse.emf.ecore.resource")
+  
+  /**  `org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl` */
+  val XMIResourceFactoryImpl = SType("XMIResourceFactoryImpl", "org.eclipse.emf.ecore.xmi.impl")
+  
   /**  `org.eclipse.emf.ecore.EObject` */
   val EcoreObject = SType("EObject", "org.eclipse.emf.ecore")
   
@@ -19,4 +28,6 @@ object PredefEcoreTypes {
   
   /**  `org.eclipse.emf.ecore.EOperation` */
   val EcoreOperation = SType("EOperation", "org.eclipse.emf.ecore")
+  
+  val ResourceSetImpl = SType("ResourceSetImpl", "org.eclipse.emf.ecore.resource.impl")
 }
\ No newline at end of file

src/main/scala/org/rosi_project/model_sync/generator/acr_model/types/PredefTypes.scala

@@ -11,6 +11,9 @@ import org.rosi_project.model_sync.generator.acr_model.{GenericSType, SType, STy
   */
 object PredefTypes {
   
+  /** `Convert Java list to Scala listApp` */
+  val ScalaConverter = SType("_", "scala.collection.JavaConverters")
+  
   /** `App` */
   val App = SType("App")
   

src/main/scala/org/rosi_project/model_sync/generator/conversion/SModelGenerator.scala

@@ -17,7 +17,8 @@ class SModelGenerator extends Converter[EPackage, SModel] {
   override def convert(source: EPackage, sourceName: String): SModel = {
     //val packageName = if (source.getName != null) source.getName else ""
     var contents = source.eAllContents().asScala
-    val model = new ComplexSModel(source.getName, sourceName)
+    val model = new ComplexSModel(source.getName, sourceName, source.getNsURI)
+    
 
     println("... Converting ecore model")    
     println("First run creates all classes, important for abstract and interface relations")

src/main/scala/org/rosi_project/model_sync/generator/sync/QueryMethods.scala

@@ -36,7 +36,7 @@ object QueryMethods  {
       result = PredefTypes.Object,
       params = Seq.empty,
       implementation = Seq(SMethodStatement(content = s"return new $helper${nat.sumSource.getName}(" + 
-          s"${nat.sumSource.getAllConstructorParameters.map(HelperFunctions.classEmptyConstructorParameterCreation(_)).mkString(", ")})", usedTypes = Set.empty)), 
+          s"${nat.sumSource.getAllConstructorParameters.map(HelperFunctions.classEmptyConstructorParameterCreation(_)).mkString(", ")})")), 
       true)    
     method.setVisibility(MethodVisibility.protectedVis)
     method
@@ -50,13 +50,13 @@ object QueryMethods  {
       name = "getCreationObject",
       result = PredefTypes.Object,
       params = Seq.empty,
-      implementation = Seq(SMethodStatement(content = "return", usedTypes = Set.empty)), 
+      implementation = Seq(SMethodStatement(content = "return")), 
       true)
     var statements: Seq[SMethodStatement] = Seq.empty
     if (ref.sumSource.connectedRef.hasOpposite) {
-      statements = Seq(SMethodStatement(content = s"target.set${ref.sumSource.connectedRef.oppositeRef.getName.capitalize}Intern(this)", usedTypes = Set.empty))
+      statements = Seq(SMethodStatement(content = s"target.set${ref.sumSource.connectedRef.oppositeRef.getName.capitalize}Intern(this)"))
     }
-    statements = statements ++ Seq(SMethodStatement(content = s"source.set${ref.sumSource.connectedRef.getName.capitalize}Intern(this)", usedTypes = Set.empty),
+    statements = statements ++ Seq(SMethodStatement(content = s"source.set${ref.sumSource.connectedRef.getName.capitalize}Intern(this)"),
         SMethodStatement(content = s"val sp: ${ref.viewSource.sumSource.getName} = source.player.right.get.asInstanceOf[${ref.viewSource.sumSource.getName}]",
             usedTypes = Set(ref.viewSource.sumSource)),
         SMethodStatement(content = s"val tp: ${ref.viewTarget.sumSource.getName} = target.player.right.get.asInstanceOf[${ref.viewTarget.sumSource.getName}]",
@@ -79,7 +79,7 @@ object QueryMethods  {
       result = PredefTypes.Unit,
       params = Seq(SMethodParameter(struc.getName.toLowerCase(), struc.getTypeElement), SMethodParameter("check", PredefRsumTypes.CHECKING_OPTION_STYPE)),
       implementation = Seq(SMethodStatement(content = s"+this set${struc.getName.firstLetterToUpperCase}(${struc.getName.toLowerCase()})", usedTypes = Set(struc.getTypeElement)), 
-          SMethodStatement(content = s"""connected.addAttributeFilter("${struc.getName}", ${struc.getName.toLowerCase()}.toString(), check)""", usedTypes = Set.empty)))
+          SMethodStatement(content = s"""connected.addAttributeFilter("${struc.getName}", ${struc.getName.toLowerCase()}.toString(), check)""")))
   }
   
   def createAllReferenceLinks(refClass: SInnerViewRelationalClass): Unit = {
@@ -112,14 +112,14 @@ object QueryMethods  {
         name = s"remove${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)), //TODO: remove this then each remove internal method has different input parameters
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = null", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = null")))
       removeMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(removeMethodInternal)
       val setMethodInternal = new SMethod(
         name = s"set${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)),
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = v", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = v")))
       setMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(setMethodInternal)
       //external variables
@@ -127,19 +127,19 @@ object QueryMethods  {
         name = s"get${realRef.getName.capitalize}",
         result = targetClass,
         params = Seq.empty,
-        implementation = Seq(SMethodStatement(content = s"return ${realRef.getName}.${getStatement}()", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"return ${realRef.getName}.${getStatement}()"))))
       sourceClass.addMethod(new SMethod(
         name = s"set${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = "if (v == null) return false", usedTypes = Set.empty),
-            SMethodStatement(content = s"if (!containsRole(v.asInstanceOf[${PredefRsumTypes.AQUERY_VIEW_ROLE_STYPE.getName}])) return false", usedTypes = Set.empty),
-            SMethodStatement(content = s"if (${realRef.getName} != null) {", usedTypes = Set.empty),
-            SMethodStatement(content = s"if (${realRef.getName}.${getStatement}() == v) return false", usedTypes = Set.empty),
-            SMethodStatement(content = s"${realRef.getName}.deleteElement()", usedTypes = Set.empty),
-            SMethodStatement(content = "}", usedTypes = Set.empty),
-            SMethodStatement(content = s"new ${refClass.getName}${thisStatement}", usedTypes = Set.empty),
-            SMethodStatement(content = "return true", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = "if (v == null) return false"),
+            SMethodStatement(content = s"if (!containsRole(v.asInstanceOf[${PredefRsumTypes.AQUERY_VIEW_ROLE_STYPE.getName}])) return false"),
+            SMethodStatement(content = s"if (${realRef.getName} != null) {"),
+            SMethodStatement(content = s"if (${realRef.getName}.${getStatement}() == v) return false"),
+            SMethodStatement(content = s"${realRef.getName}.deleteElement()"),
+            SMethodStatement(content = "}"),
+            SMethodStatement(content = s"new ${refClass.getName}${thisStatement}"),
+            SMethodStatement(content = "return true"))))
     } else {
       //add delete role for attributes
       sourceClass.getMethods.foreach(m => {
@@ -156,14 +156,14 @@ object QueryMethods  {
         name = s"remove${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)),
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} -= v", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} -= v")))
       removeMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(removeMethodInternal)
       val setMethodInternal = new SMethod(
         name = s"set${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)),
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} += v", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} += v")))
       setMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(setMethodInternal)
       //external variables
@@ -171,32 +171,32 @@ object QueryMethods  {
         name = s"get${realRef.getName.capitalize}",
         result = SSet(targetClass),
         params = Seq.empty,
-        implementation = Seq(SMethodStatement(content = s"var vs: Set[${targetClass.getDeepName}] = Set.empty", usedTypes = Set.empty), 
-            SMethodStatement(content = s"${realRef.getName}.foreach{ v => vs += v.${getStatement}()}", usedTypes = Set.empty), 
-            SMethodStatement(content = "return vs", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"var vs: Set[${targetClass.getDeepName}] = Set.empty"), 
+            SMethodStatement(content = s"${realRef.getName}.foreach{ v => vs += v.${getStatement}()}"), 
+            SMethodStatement(content = "return vs"))))
       sourceClass.addMethod(new SMethod(
         name = s"has${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = s"return get${realRef.getName.capitalize}.contains(v)", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"return get${realRef.getName.capitalize}.contains(v)"))))
       sourceClass.addMethod(new SMethod(
         name = s"add${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = s"if (has${realRef.getName.capitalize}(v) || !containsRole(v.asInstanceOf[${PredefRsumTypes.AQUERY_VIEW_ROLE_STYPE.getName}])) return false", usedTypes = Set.empty),
-            SMethodStatement(content = s"new ${refClass.getName}${thisStatement}", usedTypes = Set.empty),
-            SMethodStatement(content = "return true", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"if (has${realRef.getName.capitalize}(v) || !containsRole(v.asInstanceOf[${PredefRsumTypes.AQUERY_VIEW_ROLE_STYPE.getName}])) return false"),
+            SMethodStatement(content = s"new ${refClass.getName}${thisStatement}"),
+            SMethodStatement(content = "return true"))))
       sourceClass.addMethod(new SMethod(
         name = s"remove${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = s"if (!has${realRef.getName.capitalize}(v)) return false", usedTypes = Set.empty),
-            SMethodStatement(content = s"${realRef.getName}.foreach{ h =>", usedTypes = Set.empty),
-            SMethodStatement(content = s"if (h.${getStatement}() == v) {", usedTypes = Set.empty),
-            SMethodStatement(content = "h.deleteElement()", usedTypes = Set.empty),
-            SMethodStatement(content = "return true", usedTypes = Set.empty),
-            SMethodStatement(content = "}}", usedTypes = Set.empty),
-            SMethodStatement(content = "return true", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"if (!has${realRef.getName.capitalize}(v)) return false"),
+            SMethodStatement(content = s"${realRef.getName}.foreach{ h =>"),
+            SMethodStatement(content = s"if (h.${getStatement}() == v) {"),
+            SMethodStatement(content = "h.deleteElement()"),
+            SMethodStatement(content = "return true"),
+            SMethodStatement(content = "}}"),
+            SMethodStatement(content = "return true"))))
     }
   }
 }
\ No newline at end of file

src/main/scala/org/rosi_project/model_sync/generator/sync/SumModelReadingVisitor.scala

@@ -14,80 +14,109 @@ class SumModelReadingVisitor() extends SModelVisitor {
 
   override def visit(sModel: SModel): Unit = {
     //println("++++++++++++++++++++++++++++++++++++++++++++++")
-    val example = new SClass("Creation" + sModel.getName, PackageNames.creationPkgName)
-    example.augmentConstructor(SMethodStatement(content = s"var mapping: Map[EObject, Object] = Map.empty", usedTypes = Set(PredefEcoreTypes.EcoreObject)))
+    val creator = new SClass("Creation" + sModel.getName, PackageNames.creationPkgName)
+    val loader = new SClass("Loader" + sModel.getName, PackageNames.creationPkgName)
 
-    sModel.getAllClasses.filter(c => !c.isAbstract && !c.isInterface).foreach(c => {
+    val loadEcore = new SMethod(
+      name = "loadEcore",
+      result = PredefEcoreTypes.EcoreObject,
+      params = Seq(SMethodParameter("pathMeta", PredefTypes.String), SMethodParameter("pathInstance", PredefTypes.String)),
+      implementation = Seq(
+        SMethodStatement(content = s"require(null != pathMeta && pathMeta.nonEmpty && null != pathInstance && pathInstance.nonEmpty)"),
+        SMethodStatement(content = s"val resourceSet = new ResourceSetImpl()", usedTypes = Set(PredefEcoreTypes.ResourceSetImpl)),
+        SMethodStatement(content = s"resourceSet.getResourceFactoryRegistry.getExtensionToFactoryMap.put(Resource.Factory.Registry.DEFAULT_EXTENSION, new XMIResourceFactoryImpl())", usedTypes = Set(PredefEcoreTypes.XMIResourceFactoryImpl, PredefEcoreTypes.Resource)),
+        SMethodStatement(content = s"val ressourceMeta = resourceSet.getResource(URI.createFileURI(pathMeta), true)", usedTypes = Set(PredefEcoreTypes.URI)),
+        SMethodStatement(content = s"val packageMeta = ressourceMeta.getContents().get(0)"),
+        SMethodStatement(content = s"require(null != ressourceMeta)"),
+        SMethodStatement(content = s"require(!ressourceMeta.getContents.isEmpty)"),
+        SMethodStatement(content = s"""resourceSet.getPackageRegistry().put("${sModel.getNsURI}", packageMeta);"""),
+        SMethodStatement(content = s"val ressourceModel = resourceSet.getResource(URI.createURI(pathInstance), true);"),
+        SMethodStatement(content = s"return ressourceModel.getContents().get(0)")))
+    loader.addMethod(loadEcore)
+
+    val createModelInstance = new SMethod(
+      name = s"create${sModel.getName}Instance",
+      result = PredefTypes.Unit,
+      params = Seq(SMethodParameter("obj", PredefEcoreTypes.EcoreObject), SMethodParameter("creator", creator)),
+      implementation = Seq(
+        SMethodStatement(content = s"createObj(obj, creator)"),
+        SMethodStatement(content = s"obj.eAllContents().asScala.foreach(o => {", usedTypes = Set(PredefTypes.ScalaConverter)),
+        SMethodStatement(content = s"createObj(o, creator)"),
+        SMethodStatement(content = s"})"),
+        SMethodStatement(content = s"createRef(obj, creator)"),
+        SMethodStatement(content = s"obj.eAllContents().asScala.foreach(o => {"),
+        SMethodStatement(content = s"createRef(o, creator)"),
+        SMethodStatement(content = s"})")))
+    loader.addMethod(createModelInstance)
+
+    val createObj = new SMethod(
+      name = "createObj",
+      result = PredefTypes.Unit,
+      params = Seq(SMethodParameter("obj", PredefEcoreTypes.EcoreObject), SMethodParameter("creator", creator)),
+      implementation = Seq.empty)
+    var createObjImpl = Seq(SMethodStatement(content = s"var objName = obj.eClass.getName"),
+      SMethodStatement(content = s"objName match {"))
+
+    val createRef = new SMethod(
+      name = "createRef",
+      result = PredefTypes.Unit,
+      params = Seq(SMethodParameter("o1", PredefEcoreTypes.EcoreObject), SMethodParameter("creator", creator)),
+      implementation = Seq.empty)
+    var createRefImpl = Seq(SMethodStatement(content = s"o1.eClass().getEAllReferences.forEach(sf => {"),
+      SMethodStatement(content = s"val sfName = sf.getName"),
+      SMethodStatement(content = s"val o2 = o1.eGet(sf).asInstanceOf[EObject]"),
+      SMethodStatement(content = s"val o1Name = o1.eClass().getName"),
+      SMethodStatement(content = s"val o2Name = o2.eClass().getName"))
 
-      val metod = new SMethod(
+    creator.augmentConstructor(SMethodStatement(content = s"var mapping: Map[EObject, Object] = Map.empty", usedTypes = Set(PredefEcoreTypes.EcoreObject)))
+
+    sModel.getModelClasses.filter(c => !c.isAbstract && !c.isInterface).foreach(c => {
+      val method = new SMethod(
         name = s"create${c.getName}",
         result = PredefTypes.Unit,
-        params = c.getAllConstructorParameters :+ SMethodParameter("id", PredefEcoreTypes.EcoreObject),
+        params = c.getAttributeConstructorParameters :+ SMethodParameter("id", PredefEcoreTypes.EcoreObject),
         implementation = Seq(
-            SMethodStatement(content = s"mapping += (id -> new ${c.getName}(name, Set.empty, Set.empty, null))", usedTypes = Set.empty)))
+          SMethodStatement(content = s"mapping += (id -> new ${c.getName}(${c.getAttributeConstructorParameters.map(m => m.getName).mkString(", ")}))", usedTypes = Set(c))))
+      creator.addMethod(method)
+
+      var s = c.getAttributeConstructorParameters.map(m => s"""obj.eGet(obj.eClass().getEStructuralFeature("${m.getName}"))${if(m.getTypeName == "Boolean") ".asInstanceOf[Boolean]" else ".toString()"} """).mkString(", ")
+      if (s.isEmpty()) {
+        s = "obj"
+      } else {
+        s = s + ", obj" 
+      }
+      createObjImpl = createObjImpl :+ SMethodStatement(content = s"""case "${c.getName}" => creator.create${c.getName}(${s})""")
     })
 
     sModel.getRelationalCompartments.foreach(r => {
       var rc = r.asInstanceOf[SRelationalCompartmentClass]
-      val metod = new SMethod(
+      val method = new SMethod(
         name = s"create${r.getName}",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("s", PredefEcoreTypes.EcoreObject), SMethodParameter("t", PredefEcoreTypes.EcoreObject)),
         implementation = Seq(
           SMethodStatement(content = s"val s1 = mapping.get(s).get.asInstanceOf[${rc.sClass.getName}]"),
           SMethodStatement(content = s"val t1 = mapping.get(t).get.asInstanceOf[${rc.tClass.getName}]"),
-            SMethodStatement(content = s"(new ${rc.getName}(s1, t1)).initialize()")))
-    })
+          SMethodStatement(content = s"(new ${rc.getName}(s1, t1)).initialize()", usedTypes = Set(rc, rc.sClass, rc.tClass))))
+      creator.addMethod(method)
 
-    //add values for instances    
-    /*lines.foreach(l => {
-      l.usedType.getAllConstructorParameters.foreach(cp => {
-        if (!STypeRegistry.isDefaultType(cp.getType.getName)) {
-          val structs: Seq[EStructuralFeature] = l.obj.eClass().getEAllStructuralFeatures.asScala
-          structs.foreach(att => {
-            if (att.getName == cp.getName) {
-              val obj = l.obj.eGet(att)
-              if (obj.isInstanceOf[EObject]) {
-                lines.foreach(lnow => {
-                  if (lnow.obj == obj.asInstanceOf[EObject]) {
-                    //println("Found: " + lnow.counter) .filter(_.isInstanceOf[SRelationalCompartmentClass])
-                    sModel.getRelationalCompartments.foreach(rc => {
-                      val realRc = rc.asInstanceOf[SRelationalCompartmentClass]
-                      //println(" AN: " + att.getName + " l1: " + l.usedType.getName + " l2: " + lnow.usedType.getName + " RC: " + realRc.connectedRef.getName + " SN: " + realRc.sClass.getName + " TN: " + realRc.tClass.getName)
-                      if (realRc.connectedRef.getName == att.getName && l.usedType.proofHierarchicalEquality(realRc.sClass) && lnow.usedType.proofHierarchicalEquality(realRc.tClass)) {
-                        val s = s"(new ${realRc.getName}(${l.getName()}, ${lnow.getName()})).initialize()"
-                        generationLines = generationLines :+ new InstanceLine(0, null, realRc, s)
-                      }
+      createRefImpl = createRefImpl :+ SMethodStatement(content = s"""if (o1Name.contains("${rc.sClass.getName}") && sfName == "${rc.connectedRef.getName}" && o2Name.contains("${rc.tClass.getName}")) {""")
+      createRefImpl = createRefImpl :+ SMethodStatement(content = s"creator.create${rc.getName}(o1, o2)")
+      createRefImpl = createRefImpl :+ SMethodStatement(content = "}")
     })
-                  }
-                })
-              } else {
-                val listi: List[EObject] = EMFUtilForGenerator.getList(obj)
-                val liste = listi.asScala
-                liste.foreach(eo => {
-                  lines.foreach(lnow => {
-                    if (lnow.obj == eo) {
-                      sModel.getRelationalCompartments.foreach(rc => {
-                        val realRc = rc.asInstanceOf[SRelationalCompartmentClass]
-                        //println(" AN: " + att.getName + " l1: " + l.usedType.getName + " l2: " + lnow.usedType.getName + " RC: " + realRc.connectedRef.getName + " SN: " + realRc.sClass.getName + " TN: " + realRc.tClass.getName)
-                        if (realRc.connectedRef.getName == att.getName && l.usedType.proofHierarchicalEquality(realRc.sClass) && lnow.usedType.proofHierarchicalEquality(realRc.tClass)) {
-                          val s = s"(new ${realRc.getName}(${l.getName()}, ${lnow.getName()})).initialize()"
-                          generationLines = generationLines :+ new InstanceLine(0, null, realRc, s)
-                        }
-                      })
-                    }
-                  })
-                })
-              }
-            }
-          })
-        }
-      })
-    })*/
 
-    sModel.addModelClass(example)
-    // pass
+    createObjImpl = createObjImpl :+ SMethodStatement(content = "case _ =>")
+    createObjImpl = createObjImpl :+ SMethodStatement(content = "}")
+    createObj.implementation = createObjImpl
+    loader.addMethod(createObj)
+    
+    createRefImpl = createRefImpl :+ SMethodStatement(content = "})")
+    createRef.implementation = createRefImpl
+    loader.addMethod(createRef)
 
+    //add the new classes as model classes
+    sModel.addModelClass(creator)
+    sModel.addModelClass(loader)
   }
 
   override def visit(sClass: SClass): Unit = {

src/main/scala/org/rosi_project/model_sync/generator/sync/ViewMethods.scala

@@ -41,12 +41,12 @@ object ViewMethods {
       name = "getSource",
       result = ref.viewSource,
       params = Seq.empty,
-      implementation = Seq(SMethodStatement("source", usedTypes = Set.empty))) ++
+      implementation = Seq(SMethodStatement("source"))) ++
     new SMethod(
       name = "getTarget",
       result = ref.viewTarget,
       params = Seq.empty,
-      implementation = Seq(SMethodStatement("target", usedTypes = Set.empty))))
+      implementation = Seq(SMethodStatement("target"))))
   }
   
   def getCreateNaturalRoleMethods(naturalRoles: Set[SInnerViewNaturalClass]): Seq[SMethod] = {
@@ -57,7 +57,7 @@ object ViewMethods {
             name = s"create${nr.sumSource.getName}",
             result = nr,
             params = nr.getAllConstructorParameters,
-            implementation = Seq(SMethodStatement(content = s"return new ${nr.getName}(${nr.getAllConstructorParameters.map(m => m.getName).mkString(", ")})", usedTypes = Set.empty)))
+            implementation = Seq(SMethodStatement(content = s"return new ${nr.getName}(${nr.getAllConstructorParameters.map(m => m.getName).mkString(", ")})")))
         methods = methods :+ method
       }
     })
@@ -69,7 +69,7 @@ object ViewMethods {
       name = "isRelational",
       result = PredefTypes.Boolean,
       params = Seq.empty,
-      implementation = Seq(SMethodStatement(content = s"return ${relational}", usedTypes = Set.empty)), 
+      implementation = Seq(SMethodStatement(content = s"return ${relational}")), 
       true)    
     method.setVisibility(MethodVisibility.protectedVis)
     method
@@ -89,7 +89,7 @@ object ViewMethods {
           s"${jcls.other.getAllConstructorParameters.map(HelperFunctions.initialAttributeDoing(_, nat.getDeepStructuralFeatures)).mkString(", ")}))", usedTypes = Set(jcls.other, jcls.base)))
     } else {      
       method.implementation = Seq(SMethodStatement(content = s"return new ${nat.sumSource.getName}(" + 
-          s"${nat.sumSource.getAllConstructorParameters.map(HelperFunctions.initialAttributeDoing(_, nat.getDeepStructuralFeatures)).mkString(", ")})", usedTypes = Set.empty))
+          s"${nat.sumSource.getAllConstructorParameters.map(HelperFunctions.initialAttributeDoing(_, nat.getDeepStructuralFeatures)).mkString(", ")})"))
     }
     method.setVisibility(MethodVisibility.protectedVis)
     method
@@ -100,14 +100,14 @@ object ViewMethods {
       name = "getCreationObject",
       result = PredefTypes.Object,
       params = Seq.empty,
-      implementation = Seq(SMethodStatement(content = "return", usedTypes = Set.empty)), 
+      implementation = Seq(SMethodStatement(content = "return")), 
       true)
     var statements: Seq[SMethodStatement] = Seq.empty
     if (ref.sumSource.connectedRef.hasOpposite && createOpposite) {
-      statements = Seq(SMethodStatement(content = s"target.set${ref.sumSource.connectedRef.oppositeRef.getName.capitalize}Intern(this)", usedTypes = Set.empty))
+      statements = Seq(SMethodStatement(content = s"target.set${ref.sumSource.connectedRef.oppositeRef.getName.capitalize}Intern(this)"))
     }
     if (createNormal) {
-      statements = statements ++ SMethodStatement(content = s"source.set${ref.sumSource.connectedRef.getName.capitalize}Intern(this)", usedTypes = Set.empty)
+      statements = statements ++ SMethodStatement(content = s"source.set${ref.sumSource.connectedRef.getName.capitalize}Intern(this)")
     }
     statements = statements ++ Seq(SMethodStatement(content = s"""val sp: ${ref.sumSource.sClass.getName} = getPlayerOfType(source, "${ref.sumSource.sClass.getName}").asInstanceOf[${ref.sumSource.sClass.getName}]""",
             usedTypes = Set(ref.viewSource.sumSource)),
@@ -115,8 +115,7 @@ object ViewMethods {
             usedTypes = Set(ref.viewTarget.sumSource)),
         SMethodStatement(content = s"val v: ${ref.sumSource.getName} = new ${ref.sumSource.getName}(sp, tp)",
             usedTypes = Set(ref.sumSource)),
-        SMethodStatement(content = s"return v",
-            usedTypes = Set.empty))    
+        SMethodStatement(content = s"return v"))    
     method.implementation = statements
     method.setVisibility(MethodVisibility.protectedVis)
     method
@@ -136,7 +135,7 @@ object ViewMethods {
         statements = statements :+ SMethodStatement(content = statement, usedTypes = Set(t))
       }
     })
-    statements = statements :+ SMethodStatement(content = "return null", usedTypes = Set.empty)
+    statements = statements :+ SMethodStatement(content = "return null")
     method.implementation = statements
     method.setVisibility(MethodVisibility.protectedVis)
     method
@@ -155,7 +154,7 @@ object ViewMethods {
         s"${t.getName}(sourceRole.asInstanceOf[${t.viewSource.getName}], targetRole.asInstanceOf[${t.viewTarget.getName}])"
       statements = statements :+ SMethodStatement(content = statement, usedTypes = Set(t))
     })
-    statements = statements :+ SMethodStatement(content = "return null", usedTypes = Set.empty)
+    statements = statements :+ SMethodStatement(content = "return null")
     method.implementation = statements    
     method.setVisibility(MethodVisibility.protectedVis)
     method
@@ -204,7 +203,7 @@ object ViewMethods {
       result = PredefTypes.Unit,
       params = Seq(SMethodParameter(struc.getName.toLowerCase(), struc.getTypeElement)),
       implementation = Seq(SMethodStatement(content = s"+this set${struc.getName.firstLetterToUpperCase}(${struc.getName.toLowerCase()})", usedTypes = Set(struc.getTypeElement)), 
-          SMethodStatement(content = s"+this changeSomething()", usedTypes = Set.empty)))
+          SMethodStatement(content = s"+this changeSomething()")))
   }
   
   def createAllReferenceLinks(refClass: SInnerViewRelationalClass, createNormal: Boolean, createOpposite: Boolean): Unit = {
@@ -234,14 +233,14 @@ object ViewMethods {
         name = s"remove${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)), //TODO: remove this then each remove internal method has different input parameters
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = null", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = null")))
       removeMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(removeMethodInternal)
       val setMethodInternal = new SMethod(
         name = s"set${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)),
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = v", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} = v")))
       setMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(setMethodInternal)
       //external variables
@@ -249,19 +248,19 @@ object ViewMethods {
         name = s"get${realRef.getName.capitalize}",
         result = targetClass,
         params = Seq.empty,
-        implementation = Seq(SMethodStatement(content = s"return ${realRef.getName}.${getStatement}()", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"return ${realRef.getName}.${getStatement}()"))))
       sourceClass.addMethod(new SMethod(
         name = s"set${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = "if (v == null) return false", usedTypes = Set.empty),
-          SMethodStatement(content = "if (!containsRole(v.asInstanceOf[AViewRole])) return false", usedTypes = Set.empty),
-          SMethodStatement(content = s"if (${realRef.getName} != null) {", usedTypes = Set.empty),
-          SMethodStatement(content = s"if (${realRef.getName}.${getStatement}() == v) return false", usedTypes = Set.empty),
-          SMethodStatement(content = s"${realRef.getName}.deleteElement()", usedTypes = Set.empty),
-          SMethodStatement(content = "}", usedTypes = Set.empty),
-          SMethodStatement(content = s"new ${refClass.getName}${thisStatement}", usedTypes = Set.empty),
-          SMethodStatement(content = "return true", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = "if (v == null) return false"),
+          SMethodStatement(content = "if (!containsRole(v.asInstanceOf[AViewRole])) return false"),
+          SMethodStatement(content = s"if (${realRef.getName} != null) {"),
+          SMethodStatement(content = s"if (${realRef.getName}.${getStatement}() == v) return false"),
+          SMethodStatement(content = s"${realRef.getName}.deleteElement()"),
+          SMethodStatement(content = "}"),
+          SMethodStatement(content = s"new ${refClass.getName}${thisStatement}"),
+          SMethodStatement(content = "return true"))))
     } else {
       //upper Bound = endless
       //variable settings
@@ -271,14 +270,14 @@ object ViewMethods {
         name = s"remove${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)),
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} -= v", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} -= v")))
       removeMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(removeMethodInternal)
       val setMethodInternal = new SMethod(
         name = s"set${realRef.getName.capitalize}Intern",
         result = PredefTypes.Unit,
         params = Seq(SMethodParameter("v", refClass)),
-        implementation = Seq(SMethodStatement(content = s"${realRef.getName} += v", usedTypes = Set.empty)))
+        implementation = Seq(SMethodStatement(content = s"${realRef.getName} += v")))
       setMethodInternal.setVisibility(MethodVisibility.privateExternalClass)
       sourceClass.addMethod(setMethodInternal)
       //external variables
@@ -286,32 +285,32 @@ object ViewMethods {
         name = s"get${realRef.getName.capitalize}",
         result = SSet(targetClass),
         params = Seq.empty,
-        implementation = Seq(SMethodStatement(content = s"var vs: Set[${targetClass.getDeepName}] = Set.empty", usedTypes = Set.empty),
-          SMethodStatement(content = s"${realRef.getName}.foreach{ v => vs += v.${getStatement}()}", usedTypes = Set.empty),
-          SMethodStatement(content = "return vs", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"var vs: Set[${targetClass.getDeepName}] = Set.empty"),
+          SMethodStatement(content = s"${realRef.getName}.foreach{ v => vs += v.${getStatement}()}"),
+          SMethodStatement(content = "return vs"))))
       sourceClass.addMethod(new SMethod(
         name = s"has${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = s"return get${realRef.getName.capitalize}.contains(v)", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"return get${realRef.getName.capitalize}.contains(v)"))))
       sourceClass.addMethod(new SMethod(
         name = s"add${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = s"if (has${realRef.getName.capitalize}(v) || !containsRole(v.asInstanceOf[AViewRole])) return false", usedTypes = Set.empty),
-          SMethodStatement(content = s"new ${refClass.getName}${thisStatement}", usedTypes = Set.empty),
-          SMethodStatement(content = "return true", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"if (has${realRef.getName.capitalize}(v) || !containsRole(v.asInstanceOf[AViewRole])) return false"),
+          SMethodStatement(content = s"new ${refClass.getName}${thisStatement}"),
+          SMethodStatement(content = "return true"))))
       sourceClass.addMethod(new SMethod(
         name = s"remove${realRef.getName.capitalize}",
         result = PredefTypes.Boolean,
         params = Seq(SMethodParameter("v", targetClass)),
-        implementation = Seq(SMethodStatement(content = s"if (!has${realRef.getName.capitalize}(v)) return false", usedTypes = Set.empty),
-          SMethodStatement(content = s"${realRef.getName}.foreach{ h =>", usedTypes = Set.empty),
-          SMethodStatement(content = s"if (h.${getStatement}() == v) {", usedTypes = Set.empty),
-          SMethodStatement(content = "h.deleteElement()", usedTypes = Set.empty),
-          SMethodStatement(content = "return true", usedTypes = Set.empty),
-          SMethodStatement(content = "}}", usedTypes = Set.empty),
-          SMethodStatement(content = "return true", usedTypes = Set.empty))))
+        implementation = Seq(SMethodStatement(content = s"if (!has${realRef.getName.capitalize}(v)) return false"),
+          SMethodStatement(content = s"${realRef.getName}.foreach{ h =>"),
+          SMethodStatement(content = s"if (h.${getStatement}() == v) {"),
+          SMethodStatement(content = "h.deleteElement()"),
+          SMethodStatement(content = "return true"),
+          SMethodStatement(content = "}}"),
+          SMethodStatement(content = "return true"))))
     }
   }
 }
\ No newline at end of file

src/main/scala/org/rosi_project/model_sync/generator/test/ApplicationTest.scala

@@ -13,8 +13,8 @@ object ApplicationTest extends App {
   //runTestAML(Creation.rolesum)
   
   //TTC Case examples
-  //runTTC2019(Creation.rolecomb)
-  runTTC2019(Creation.rolesync)  
+  runTTC2019(Creation.rolecomb)
+  //runTTC2019(Creation.rolesync)  
   //runTTCLive2019(Creation.rolesync)
 
   //Run all tests

src/main/scala/org/rosi_project/model_sync/generator/test/SModelFSWriterTest.scala

@@ -8,7 +8,7 @@ import scala.collection.Seq
   */
 object SModelFSWriterTest/* extends App */{
 
-  val model = new SimpleSModel("Foo", "source")
+  val model = new SimpleSModel("Foo", "source", "http.//test.test")
 
   val stringType = SType("String")