Remove error in used types and necessary imports

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

@@ -100,7 +100,18 @@ class SClass(_name: String,
   }
   
   /** Gets the parents of `this` class. */
-  def getAllParents(): Seq[STypedElement] = parentInterfaces :+ parentClass
+  def getAllParents(): Seq[STypedElement] = {
+    if (parentInterfaces.isEmpty && parentClass == null) {
+      return Seq.empty
+    }
+    if (parentInterfaces.isEmpty) {
+      return Seq(parentClass)
+    }
+    if (parentClass == null) {
+      return parentInterfaces
+    }
+    parentInterfaces :+ parentClass
+  }
 
   /** Makes `this` class a subclass of `parent`.
     *
@@ -183,18 +194,24 @@ class SClass(_name: String,
 
   /** Provides all types `this` classes accesses in some way. */
   def getUsedTypes: Set[STypedElement] = {
-    println(this + " Parents: " + getAllParents)
-    val parentImport: Seq[STypedElement] = getAllParents() //TODO: weiß nicht ob null mit in der liste steht
+    //println(this + " Parents: " + getAllParents)
+    val parentImport: Seq[STypedElement] = getAllParents()
 
     val parentConstructorParamImports: Seq[STypedElement] = if (isRootClass) List() else getClassParent match {
-      case parent: SClass => parent.getStructuralFeatures.map(_.sType)
+      case parent: SClass => 
+        println(parent.getDeepStructuralFeatures)
+        println(parent.getDeepStructuralFeatures.map(_.sType))
+        parent.getDeepStructuralFeatures.map(_.sType)
       case _ => List()
     }
 
+    //attribute types
     val attrTypeImports: Seq[STypedElement] = attributes.map(_.sType)
     
+    //reference types
     val refTypeImports: Seq[STypedElement] = references.map(_.sType)
 
+    //method types
     val methodResultImports: Seq[STypedElement] = methods.map(_.result)
 
     val methodParamImports: Seq[STypedElement] = methods.flatMap(_.params).map(_.paramType)
@@ -220,54 +237,48 @@ class SClass(_name: String,
   override def getInheritanceHierarchy: Seq[STypedElement] = if (isRootClass) List(this) else this +: getClassParent.getInheritanceHierarchy
 
   override def getNecessaryImports: Set[SImport] = {    
-    val parentImport: List[SImport] = if (isRootClass) List() else includeImportIfNecessary(getClassParent.getPackage, getClassParent.getName)
-
-    val parentConstructorParamImports: List[SImport] = if (isRootClass) List() else getClassParent match {
+    var allImports: List[SImport] = List.empty
+    //iterate over all parent types
+    getAllParents().foreach(p => {
+      allImports = includeImportIfNecessary(p.sPackage, p.name, allImports) 
+    })
+    
+    //iterate over construction features of parent types
+    if (!isRootClass) {
+      getClassParent match {
         case parent: SClass =>
-        parent.attributes
-          .map(attr => includeImportIfNecessary(attr.sType.getPackage, attr.sType.getName))
-          .fold(List())((l1, l2) => l1 ++ l2)
+          parent.getStructuralFeatures.foreach(p => {
+            allImports = includeImportIfNecessary(p.sType.getPackage, p.getType, allImports) 
+          })
         case _ => List()
       }
+    }
     
-    val attrTypeImports: List[SImport] =
-      attributes
-        .map(attr => includeImportIfNecessary(attr.sType.getPackage, attr.getType))
-        .fold(List())((l1, l2) => l1 ++ l2)
-        
-    val refTypeImports: List[SImport] =
-      references
-        .map(attr => includeImportIfNecessary(attr.sType.getPackage, attr.getType))
-        .fold(List())((l1, l2) => l1 ++ l2)
-
-    val methodResultImports: List[SImport] =
-      methods
-        .map(_.result)
-        .map(res => includeImportIfNecessary(res.getPackage, res.getName))
-        .fold(List())((l1, l2) => l1 ++ l2)
+    //iterate over all attributes
+    attributes.foreach(a => {
+      allImports = includeImportIfNecessary(a.sType.getPackage, a.getType, allImports) 
+    })
     
-    val methodParamImports: List[SImport] =
-      methods
-        .map(_.params)
-        .fold(List())((l1, l2) => l1 ++ l2)
-        .map(param => includeImportIfNecessary(param.paramType.getPackage, param.paramType.getName))
-        .fold(List())((l1, l2) => l1 ++ l2)
+    //iterate over all references
+    references.foreach(r => {
+      allImports = includeImportIfNecessary(r.sType.getPackage, r.getType, allImports) 
+    })
     
-    val methodImplImports: List[SImport] =
-      methods
-        .map(_.getUsedTypes.toList)
-        .fold(List())((l1, l2) => l1 ++ l2)
-        .map(typ => includeImportIfNecessary(typ.getPackage, typ.getName))
-        .fold(List())((l1, l2) => l1 ++ l2)
+    methods.foreach(m => {
+      //iterate over result types
+      allImports = includeImportIfNecessary(m.result.getPackage, m.result.getName, allImports)
+      //iterate over parameter types
+      m.params.foreach(p => {
+        allImports = includeImportIfNecessary(p.paramType.getPackage, p.paramType.getName, allImports)
+      })
+      //iterate over used types in the method
+      m.getUsedTypes.foreach(t => {
+        allImports = includeImportIfNecessary(t.getPackage, t.getName, allImports)
+      })
+    })
 
     // create a set to eliminate duplicates
-    (parentImport
-      ++ parentConstructorParamImports
-      ++ attrTypeImports
-      ++ refTypeImports
-      ++ methodResultImports
-      ++ methodParamImports
-      ++ methodImplImports).toSet
+    (allImports).toSet
   }
 
   override def accept(visitor: SModelVisitor): Unit = {
@@ -287,8 +298,8 @@ class SClass(_name: String,
     * @return an empty list if the class does not need to be imported, or the necessary import
     *         otherwise
     */
-  private def includeImportIfNecessary(sPackage: String, sClass: String): List[SImport] = {
-    if (sPackage != this.sPackage && sPackage != "") List(SImport(sPackage, sClass)) else List()
+  private def includeImportIfNecessary(sPackage: String, sClass: String, list: List[SImport]): List[SImport] = {
+    if (sPackage != this.sPackage && sPackage != "") list :+ SImport(sPackage, sClass) else list
   }
   
   override def equals(other: Any): Boolean = other match {
@@ -304,6 +315,6 @@ class SClass(_name: String,
     state.map(_.hashCode()).foldLeft(0)((a, b) => 31 * a + b)
   }
 
-  override def toString: String = s"$name(${attributes.map(_.name).mkString(", ")}) A: $isAbstract I: $isInterface"
+  override def toString: String = s"SC: $name(${attributes.map(_.name).mkString(", ")}, $isAbstract, $isInterface)"
 
 }

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

@@ -14,6 +14,8 @@ package org.rosi_project.model_sync.generator.acr_model
 case class SType(_name: String, _sPackage: String = "", _isInterface: Boolean = true) extends STypedElement (_name, _sPackage, _isInterface) {
 
   override def accept(visitor: SModelVisitor): Unit = visitor.visit(this)
+  
+  override def toString: String = s"ST: $name($sPackage, $isInterface)"
 }
 
 /** The companion defines frequently used types.

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

@@ -14,8 +14,7 @@ abstract class STypedElement (_name: String,
              val sPackage: String,
              var isInterface: Boolean) extends SNamedModelElement(_name) {
   
-  /** Checks, whether `this` is part of the default package
-    */
+  /** Checks, whether `this` is part of the default package */
   def isDefaultPackage: Boolean = sPackage == ""
 
   /** The package containing `this` type.
@@ -24,8 +23,7 @@ abstract class STypedElement (_name: String,
     */
   def getPackage: String = sPackage
 
-  /** The parameters necessary to create an instance of `this` type.
-    */
+  /** The parameters necessary to create an instance of `this` type. */
   def getConstructorParameters: Seq[SMethodParameter] = Seq.empty
 
   /** The inheritance hierarchy provides information about the types `this` extends. It will start
@@ -38,4 +36,6 @@ abstract class STypedElement (_name: String,
     */
   def getNecessaryImports: Set[SImport] = Set.empty
   
+  override def toString: String = s"STE: $name($sPackage, $isInterface)"
+
 }

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

@@ -8,6 +8,7 @@ class SList(elemType: STypedElement) extends SSeq(elemType) {
 
   override def getConstructorParameters: Seq[SMethodParameter] = Seq(SMethodParameter("elems", elemType))
 
+  override def toString: String = s"List: $elemType"
 }
 
 /** The companion provides `apply` and `unapply` methods.

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

@@ -8,6 +8,7 @@ class SSeq(val elemType: STypedElement) extends GenericSType(name = "Seq", sPack
 
   override def getConstructorParameters: Seq[SMethodParameter] = Seq(SMethodParameter("elems", elemType))
 
+  override def toString: String = s"Seq: $elemType"
 }
 
 /** The companion provides `apply` and `unapply` methods.

src/main/scala/org/rosi_project/model_sync/generator/io/SClassWriter.scala

@@ -99,11 +99,11 @@ class SClassWriter(val modelClass: SClass) {
     
     val constructor: String = s"(${params.mkString(", ")})"
     
-    println("params: " + params)
+    /*println("params: " + params)
     println("parentConstructorParams: " + parentConstructorParams)
     println("parentConstructor: " + parentConstructor)
     println("allInterfaces: " + allInterfaces)
-    println("constructor: " + constructor)
+    println("constructor: " + constructor)*/
     
     if (modelClass.isInterface) {
       baseFixture = s"trait ${modelClass.getName}"

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

@@ -40,7 +40,16 @@ class ConstructorTemplate(modelClass: SClass) extends SClass(_name = s"${modelCl
     )
   )
 
-  override def getNecessaryImports: Set[SImport] = modelClass.getUsedTypes.filter(_.getPackage != "").map(elem => SImport(elem.getPackage, elem.getName)) ++ super.getNecessaryImports + SImport(modelClass.getPackage, modelClass.getName)
+  override def getNecessaryImports: Set[SImport] = {
+    println("+++++++++++++++++++++++++")
+    println(modelClass.getUsedTypes.filter(_.getPackage != "").map(elem => SImport(elem.getPackage, elem.getName)))
+    println(super.getNecessaryImports)
+    println(SImport(modelClass.getPackage, modelClass.getName))
+    println("+++++++++++++++++++++++++")
+    (modelClass.getUsedTypes.filter(_.getPackage != "").map(elem => SImport(elem.getPackage, elem.getName)) 
+      ++ super.getNecessaryImports 
+      + SImport(modelClass.getPackage, modelClass.getName))      
+  }
 
   private def generateConstructorParams: String = {
     modelClass.getDeepStructuralFeatures.map(attr => s"classOf[${attr.getType}]").mkString(", ")