Configurations for generation and new domain for generation ecore model

2 files changed, 149 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ConstraintCollection.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ConstraintCollection.xtend
new file mode 100644
index 00000000..685c5836
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ConstraintCollection.xtend
@@ -0,0 +1,80 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation
+
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import org.eclipse.emf.common.notify.Notifier
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+
+class ConstraintCollection{
+        val constraints = new ArrayList<IConstraintSpecification>();
+        var BaseGeneratedPatternGroup patterns;
+        var List<Notifier> resources = new ArrayList<Notifier>(); 
+        
+        
+        new(List<IConstraintSpecification> constraints, List<String> uris, BaseGeneratedPatternGroup patterns){
+                this.constraints.addAll(constraints);
+                this.patterns = patterns;
+                setURIs(uris);
+        }
+        
+        new(List<IConstraintSpecification> constraints, BaseGeneratedPatternGroup patterns){
+                this.constraints.addAll(constraints);
+                this.patterns = patterns;
+        }
+        
+        def addModel(Notifier n ){
+                resources.add(n);
+        }
+        
+        def setURIs(List<String> uris){
+                val resSet = new ResourceSetImpl();
+                
+                for(uri : uris){
+                        var resource = resSet.getResource(URI.createURI(uri), true);
+                        resources.add(resource);
+                }
+        
+                println('reading model finished')
+        }
+        
+        def List<Integer> calculateViolations(){
+                var results = new ArrayList<Integer>();
+                
+                for(resource : resources){
+                        val engine = initEngine(resource);
+                        var matches = constraints.stream.mapToInt([ele| ele.querySpecification.getMatcher(engine).countMatches]).sum();
+                        results.add(matches);
+                }
+                
+                return results;
+        }
+        
+        def ArrayList<Map<String, Integer>> calculateViolationMaps(){
+                val result = new ArrayList<Map<String, Integer>>()
+                
+                for(resource : resources){
+                        val map = new HashMap<String, Integer>();
+                        val engine = initEngine(resource);
+                        constraints.forEach[
+                                var count = it.querySpecification.getMatcher(engine).countMatches;
+                                map.put(it.querySpecification.simpleName, count);
+                        ];
+                        result.add(map);
+                }
+                return result;
+        }
+        
+        private def initEngine(Notifier r){
+                var engine = ViatraQueryEngine.on(new EMFScope(r));
+                //init patterns with the new engine
+                patterns.prepare(engine);
+                return engine;
+        }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ViolationCheck.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ViolationCheck.xtend
new file mode 100644
index 00000000..72239e22
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ViolationCheck.xtend
@@ -0,0 +1,69 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import com.google.common.reflect.ClassPath
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns
+import java.util.ArrayList
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification
+
+class ViolationCheck {
+        /**
+         * Return the total number of violations
+         */
+        def static int calculateViolationCounts(EObject root, Domain d){
+                var packageName = '';
+                if(d == Domain.Yakindumm){
+                        packageName = 'constraints.yakindumm';
+                }else if (d == Domain.Ecore){
+                        //TODO: put constraints package names for ecore and github models
+                        return -1;
+                }else if (d == Domain.Github){
+                        return -1;
+                }
+                
+                
+                var constriants = loadConstraints(packageName);
+                var collections = new ConstraintCollection(constriants, Patterns.instance);
+                collections.addModel(root);
+                var results = collections.calculateViolations();
+                if(results.size > 0){
+                        return results.get(0);
+                }else{
+                        throw new IllegalArgumentException("Calculate Violation Failed");
+                }
+        }
+        
+        /**
+         * return a map contain the count for each type of violation
+         */
+        def static violationMaps(EObject root){
+                var constriants = loadConstraints('hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu');
+                var collections = new ConstraintCollection(constriants, Patterns.instance);
+                collections.addModel(root);
+                var results = collections.calculateViolationMaps();
+                if(results.size > 0){
+                        return results.get(0);
+                }else{
+                        throw new IllegalArgumentException("Calculate Violation Failed");
+                }
+        }
+        
+        def static loadConstraints(String packageName){
+                val constraints = new ArrayList<IConstraintSpecification>();
+                
+                val classPath = ClassPath.from(ClassLoader.systemClassLoader);
+                val classInfos = classPath.getTopLevelClasses(packageName);
+                
+                for(info : classInfos){
+                        if(info.load.interfaces.contains(IConstraintSpecification)){
+                                //IConstraintSpecification only has one constructor with empty argument list
+                                var constructor = info.load.constructors.get(0);
+                                var instance = constructor.newInstance();
+                                constraints.add(instance as IConstraintSpecification);
+                        }
+                }
+                
+                return constraints
+        }
+}