4 files changed, 139 insertions, 59 deletions

diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend
index cae489e3..85b488eb 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend
+++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend
@@ -1,7 +1,13 @@
 package hu.bme.mit.inf.dslreasoner.ecore2logic

 

+import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

+import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription

+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import java.util.List

+import java.util.Set

 import org.eclipse.emf.ecore.EAttribute

 import org.eclipse.emf.ecore.EClass

 import org.eclipse.emf.ecore.EEnum

@@ -9,10 +15,6 @@ import org.eclipse.emf.ecore.EEnumLiteral
 import org.eclipse.emf.ecore.EReference

 import org.eclipse.xtend.lib.annotations.Data

 import org.eclipse.xtend.lib.annotations.Delegate

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

-import java.util.Set

-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy

 

 @Data class EcoreMetamodelDescriptor {

         val List<EClass> classes;

diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/src/hu/bme/mit/inf/dslreasoner/logic/model/builder/LogicModelInterpretation.xtend b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/src/hu/bme/mit/inf/dslreasoner/logic/model/builder/LogicModelInterpretation.xtend
index 905859eb..cdcbb48a 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/src/hu/bme/mit/inf/dslreasoner/logic/model/builder/LogicModelInterpretation.xtend
+++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/src/hu/bme/mit/inf/dslreasoner/logic/model/builder/LogicModelInterpretation.xtend
@@ -3,22 +3,27 @@ package hu.bme.mit.inf.dslreasoner.logic.model.builder
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

+import java.math.BigDecimal

 import java.util.List

+import java.util.Map

+import java.util.SortedSet

+import java.util.TreeSet

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import java.util.SortedSet

-import java.math.BigDecimal

 

-interface LogicModelInterpretation{

-        

+interface LogicModelInterpretation {

+

         /**

          * Returns the elements of a type.

-         */     

+         */

         def List<DefinedElement> getElements(Type type)

+

         /**

          * Returns the interpretation of a function. The parameters and the return values are encoded to primitive java objects defined by the following table:

          * <p><table>

@@ -34,6 +39,7 @@ interface LogicModelInterpretation{
          * @return The result of the function call encoded as defined in the table.

          */

         def Object getInterpretation(FunctionDeclaration function, Object[] parameterSubstitution)

+

         /**

          * Returns the interpretation of a relation. The parameters are encoded to primitive java objects defined by the following table:

          * <p><table>

@@ -49,6 +55,7 @@ interface LogicModelInterpretation{
          * @return If the parameter tuple is in the relation.

          */

         def boolean getInterpretation(RelationDeclaration relation, Object[] parameterSubstitution)

+

         /**

          * Returns the interpretation of a constant. The value is encoded to primitive java objects defined by the following table:

          * <p><table>

@@ -63,60 +70,89 @@ interface LogicModelInterpretation{
          * @return The value of the constant encoded as specified in the table.

          */

         def Object getInterpretation(ConstantDeclaration constant)

-        

+

         /**

          * Returns all integers relevant to the logic structure. Not all integer is necessarily used.

          */

         def SortedSet<Integer> getAllIntegersInStructure()

+

+        def Map<TermDescription, Integer> getAllIntegersWithInterpretation() {

+                allIntegersInStructure.toMap [ integer |

+                        (LogiclanguageFactory.eINSTANCE.createIntLiteral => [value = integer]) as TermDescription

+                ]

+        }

+

         /**

          * Returns all real numbers relevant to the logic structure. Not all integer is necessarily used.

          */

-         def SortedSet<BigDecimal> getAllRealsInStructure()

-         /**

+        def SortedSet<BigDecimal> getAllRealsInStructure()

+

+        def Map<TermDescription, BigDecimal> getAllRealsWithInterpretation() {

+                allRealsInStructure.toMap [ real |

+                        (LogiclanguageFactory.eINSTANCE.createRealLiteral => [value = real]) as TermDescription

+                ]

+        }

+

+        /**

          * Returns all string values relevant to the logic structure. Not all integer is necessarily used.

          */

-         def SortedSet<String> getAllStringsInStructure()

+        def SortedSet<String> getAllStringsInStructure()

+        

+        def Map<TermDescription, String> getAllStringsWithInterpretation() {

+                allStringsInStructure.toMap [ string |

+                        (LogiclanguageFactory.eINSTANCE.createStringLiteral => [value = string]) as TermDescription

+                ]

+        }

+        

+        def SortedSet<Boolean> getAllBooleansInStructure() {

+                new TreeSet(#{true, false})

+        }

+        

+        def Map<TermDescription, Boolean> getAllBooleansWithInterpretation() {

+                allBooleansInStructure.toMap [ bool |

+                        (LogiclanguageFactory.eINSTANCE.createBoolLiteral => [value = bool]) as TermDescription

+                ]

+        }

 }

 

 class Uninterpreted implements LogicModelInterpretation {

         /*private val static unknownBecauseUninterpreted = LogiclanguageFactory.eINSTANCE.createUnknownBecauseUninterpreted

-        public def static getUnknownBecauseUninterpreted() {return Uninterpreted.unknownBecauseUninterpreted}*/

-        

+         public def static getUnknownBecauseUninterpreted() {return Uninterpreted.unknownBecauseUninterpreted}*/

         override getElements(Type type) {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-        

+

         def getKnownElements(Type type) {

                 val allSubtypes = type.transitiveClosureStar[it.subtypes]

                 return allSubtypes.filter(TypeDefinition).map[elements].flatten.toList

         }

-        

+

         def allElementsAreInterpreted(Type type) {

                 val allSubtypes = type.transitiveClosureStar[it.subtypes]

                 return allSubtypes.exists[it instanceof TypeDeclaration]

         }

-        

+

         override getInterpretation(FunctionDeclaration function, Object[] parameterSubstitution) {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-        

+

         override getInterpretation(RelationDeclaration relation, Object[] parameterSubstitution) {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-        

+

         override getInterpretation(ConstantDeclaration constant) {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-        

+

         override getAllIntegersInStructure() {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-        

+

         override getAllRealsInStructure() {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-        

+

         override getAllStringsInStructure() {

                 throw new UnsupportedOperationException("The interpteration is unknown.")

         }

-}
\ No newline at end of file
+}

diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic2ecore/src/hu/bme/mit/inf/dslreasoner/logic2ecore/Logic2Ecore.xtend b/Framework/hu.bme.mit.inf.dslreasoner.logic2ecore/src/hu/bme/mit/inf/dslreasoner/logic2ecore/Logic2Ecore.xtend
index 08c6b7b7..8d6b565a 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.logic2ecore/src/hu/bme/mit/inf/dslreasoner/logic2ecore/Logic2Ecore.xtend
+++ b/Framework/hu.bme.mit.inf.dslreasoner.logic2ecore/src/hu/bme/mit/inf/dslreasoner/logic2ecore/Logic2Ecore.xtend
@@ -3,25 +3,24 @@ package hu.bme.mit.inf.dslreasoner.logic2ecore
 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation

+import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicStructureBuilder

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription

+import java.math.BigDecimal

 import java.util.Collection

 import java.util.HashMap

 import java.util.HashSet

 import java.util.List

+import java.util.Map

 import java.util.Set

 import org.eclipse.emf.ecore.EClass

+import org.eclipse.emf.ecore.EDataType

+import org.eclipse.emf.ecore.EEnum

 import org.eclipse.emf.ecore.EObject

 import org.eclipse.emf.ecore.EStructuralFeature

+import org.eclipse.emf.ecore.EcorePackage

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import org.eclipse.emf.ecore.EEnum

-import org.eclipse.emf.ecore.EDataType

-import org.eclipse.emf.ecore.EcorePackage

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder

-import java.util.Map

-import org.eclipse.emf.ecore.EAttribute

-import java.math.BigDecimal

 

 class Logic2Ecore {

         val extension LogicStructureBuilder structureBuilder = new LogicStructureBuilder

@@ -86,15 +85,15 @@ class Logic2Ecore {
                                         if(attributeType.EContainingClass.isSuperTypeOf(sourceObject.eClass)) {

                                                 val allElementsOfTargetDatatype = getAllElementsOfDatatype(attributeType.EAttributeType,forwardTrace,interpretation)

                                                 for(l : allElementsOfTargetDatatype.entrySet) {

-                                                        val expression = ecore2Logic.IsAttributeValue(forwardTrace,sourceElement,l.value,attributeType)

+                                                        val expression = ecore2Logic.IsAttributeValue(forwardTrace,sourceElement,l.key,attributeType)

                                                         val linkExist = interpretation.evalAsBool(expression)

                                                         if(linkExist) {

                                                                 if(attributeType.isMany) {

                                                                         val list = sourceObject.eGet(attributeType) as List<? super Object>

-                                                                        list += l.key

+                                                                        list += l.value

                                                                 } else {

                                                                         try {

-                                                                                sourceObject.eSet(attributeType,translateType(attributeType.EAttributeType,l.key))

+                                                                                sourceObject.eSet(attributeType,translateType(attributeType.EAttributeType,l.value))

                                                                         } catch(Exception e) {

                                                                                 e.printStackTrace

                                                                         }

@@ -119,34 +118,20 @@ class Logic2Ecore {
                 } else return value

         }

         

-        

-//                                                      if(attributeType.EAttributeType.isSuperTypeOf(targetObject.eClass)) {

-//                                                              val expression = ecore2Logic.IsAttributeValue(forwardTrace,sourceElement,targetElement,attributeType)

-//                                                              val linkExist = interpretation.evalAsBool(expression)

-//                                                              if(linkExist) {

-//                                                                      if(attributeType.isMany) {

-//                                                                                      val list = sourceObject.eGet(attributeType) as List<? super EObject>

-//                                                                                      list+= targetObject

-//                                                                              } else {

-//                                                                                      sourceObject.eSet(referenceType,targetObject)

-//                                                                              }

-//                                                              }

-//                                                      }

-        

-        protected dispatch def Map<? extends Object, ? extends TermDescription> getAllElementsOfDatatype(EEnum type, Ecore2Logic_Trace forwardTrace, LogicModelInterpretation interpretation) {

-                ecore2Logic.allLiteralsInScope(forwardTrace).toInvertedMap[ecore2Logic.Literal(forwardTrace,it)]

+        protected dispatch def Map<? extends TermDescription, ? extends Object> getAllElementsOfDatatype(EEnum type, Ecore2Logic_Trace forwardTrace, LogicModelInterpretation interpretation) {

+                ecore2Logic.allLiteralsInScope(forwardTrace).toMap[ecore2Logic.Literal(forwardTrace,it)]

         }

         

-        protected dispatch def Map<? extends Object, ? extends TermDescription> getAllElementsOfDatatype(EDataType primitive, Ecore2Logic_Trace forwardTrace, LogicModelInterpretation interpretation) {

+        protected dispatch def Map<? extends TermDescription, ? extends Object> getAllElementsOfDatatype(EDataType primitive, Ecore2Logic_Trace forwardTrace, LogicModelInterpretation interpretation) {

                 val extension LogicProblemBuilder b = new LogicProblemBuilder

                 if(primitive === EcorePackage.eINSTANCE.EInt || primitive === EcorePackage.eINSTANCE.EShort || primitive === EcorePackage.eINSTANCE.ELong) {

-                        interpretation.allIntegersInStructure.toInvertedMap[it.asTerm]

+                        interpretation.allIntegersWithInterpretation

                 } else if(primitive === EcorePackage.eINSTANCE.EDouble || primitive === EcorePackage.eINSTANCE.EFloat) {

-                        interpretation.allRealsInStructure.toInvertedMap[it.asTerm]

+                        interpretation.allRealsWithInterpretation

                 } else if(primitive === EcorePackage.eINSTANCE.EString) {

-                        interpretation.allStringsInStructure.toInvertedMap[it.asTerm]

+                        interpretation.allStringsWithInterpretation

                 } else if(primitive === EcorePackage.eINSTANCE.EBoolean) {

-                        return #[false,true].toInvertedMap[it.asTerm]

+                        interpretation.allBooleansWithInterpretation

                 }

         }

         

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
index f61c7333..48922f5d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

 

+import com.google.common.collect.ImmutableMap

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

@@ -153,14 +154,70 @@ class PartialModelAsLogicInterpretation implements LogicModelInterpretation{
         }

         

         override getAllIntegersInStructure() {

-                new TreeSet(this.integerForwardTrace.keySet)

+                new TreeSet(allIntegersWithInterpretation.values)

+        }

+        

+        override getAllIntegersWithInterpretation() {

+                val builder = new HashMap

+                for (entry : integerForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof IntegerElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

         }

         

         override getAllRealsInStructure() {

-                new TreeSet(this.realForwardTrace.keySet)

+                new TreeSet(allRealsWithInterpretation.values)

+        }

+        

+        override getAllRealsWithInterpretation() {

+                val builder = new HashMap

+                for (entry : realForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof RealElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

         }

         

         override getAllStringsInStructure() {

-                new TreeSet(this.stringForwardTrace.keySet)

+                new TreeSet(allStringsWithInterpretation.values)

+        }

+        

+        override getAllStringsWithInterpretation() {

+                val builder = new HashMap

+                for (entry : stringForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof StringElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

+        }

+        

+        override getAllBooleansInStructure() {

+                new TreeSet(allBooleansWithInterpretation.values)

+        }

+        

+        override getAllBooleansWithInterpretation() {

+                val builder = new HashMap

+                for (entry : booleanForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof BooleanElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

         }

 }
\ No newline at end of file