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>