1 files changed, 194 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
new file mode 100644
index 00000000..31788bb2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
@@ -0,0 +1,194 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import com.google.common.collect.ArrayListMultimap
+import com.google.common.collect.Multimap
+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.EObject
+import org.eclipse.emf.ecore.EReference
+
+class GraphStatistic {
+        val incomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+        val outgoingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+
+        val edgeTypes = new HashSet<String>();
+        val nodeToType = new HashMap<EObject, Set<String>>();   
+
+        /**
+         * Add an edge type to to the graph
+         * @param type: type to add
+         */
+        def void addEdgeType(String type){
+                if(edgeTypes.contains(type)){
+                        return;
+                }
+                
+                edgeTypes.add(type);
+                incomingEdges.put(type, ArrayListMultimap.create());
+                outgoingEdges.put(type, ArrayListMultimap.create());
+        }
+        
+        /**
+         * Add a node to the graph with one type in its type hierarchy
+         * @param node: node to add
+         */
+         def void addNodeWithType(EObject n, String Type){
+                var types = nodeToType.getOrDefault(n, new HashSet<String>());
+                types.add(Type);
+                nodeToType.put(n, types);
+         }
+         
+         def boolean containsNode(EObject o){
+                return nodeToType.containsKey(o);
+         }
+         
+         def Set<String> getTypesForNode(EObject o){
+                return nodeToType.getOrDefault(o, new HashSet<String>());
+         }
+         
+         def void overwriteCurrentType(EObject o, String type){
+                var typeSet = nodeToType.getOrDefault(o, new HashSet<String>());
+                
+                // clear current types
+                typeSet.clear();
+                typeSet.add(type);
+                nodeToType.put(o, typeSet);
+         }
+         
+         /**
+          * Add a node to the graph with all types in its type hierarchy
+          */
+         def void addNodeWithAllTypes(EObject n, Set<String> types){
+                nodeToType.put(n, types);
+         }
+         
+         /**
+          * Add an edge to the graph
+          * @param source: source node
+          * @param target: target node
+          * @param type: type of the reference
+          */
+          def void addEdge(EObject source, EObject target, String type){
+                outgoingEdges.get(type).put(source, target);
+                incomingEdges.get(type).put(target, source);
+          }
+          
+          /**
+           * check if this graph contains a specific edge type
+           */
+           def boolean containsEdgeType(String typeName){
+                 if(outgoingEdges.containsKey(typeName) && incomingEdges.containsKey(typeName)){
+                        return true;
+                 }
+                 return false;
+           }
+           
+           /**
+            * remove references from the statistics, potentially remove the nodes associated with it
+            * @Param name: name of the reference
+            * @Param isContainment: if true then the corresponding nodes on the incoming side will also be removed
+            */
+            def removeReference(String name, boolean isContainment){
+                if(!edgeTypes.contains(name)){
+                        return;
+                }
+                
+                edgeTypes.remove(name);
+                var incomingSet = incomingEdges.remove(name);
+                outgoingEdges.remove(name);
+                
+                // if the reference is not a containment, then removing the reference is enough
+                if(!isContainment){
+                        return;
+                }
+                
+                // else remove all corresponding nodes
+                val nodesToRemove = incomingSet.keySet();
+                
+                //remove nodes from node sets
+                nodesToRemove.forEach[nodeToType.remove(it)];
+                
+                val removeForMultimap = [Multimap<EObject, EObject> refMap| 
+                        nodesToRemove.forEach[refMap.removeAll(it)];
+                        var values = refMap.values()
+                        //remove the values from the list is equavalent to remove it in the multimap
+                        values.removeAll(nodesToRemove); 
+                        return;
+                ];
+                
+                //remove nodes from all other references on incomingEdges
+                incomingEdges.values.forEach(removeForMultimap);
+                outgoingEdges.values.forEach(removeForMultimap);
+            }
+          
+          /**
+           * calculate the out degree for an object
+           */
+          def int outDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += outgoingEdges.get(type).get(o).size();
+                }
+                return count;
+          }
+          
+          /**
+           * calculate the in degree of an object
+           */
+          def int inDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += incomingEdges.get(type).get(o).size();
+                }
+                return count;
+          }
+          
+          /**
+           * calculate the dimentional degree of a node
+           */
+          def int dimentionalDegree(EObject o, String type){
+                return incomingEdges.get(type).get(o).size() + outgoingEdges.get(type).get(o).size();
+          }
+          
+          /**
+           * calculate the number of edge types for a given node.
+           */
+          def int numOfEdgeTypes(EObject o){
+                var count = 0;
+                
+                for(String type : edgeTypes){
+                        if(dimentionalDegree(o, type) > 0){
+                                count++;
+                        }
+                }
+                
+                return count;
+          }
+          
+          def List<String> getAllTypes(){
+                return edgeTypes.toList();
+          }
+          
+          def Map<EObject, Set<String>> getNodeToTypesMap(){
+                return nodeToType;
+          }
+          
+          def List<EObject> getAllNodes(){
+                return nodeToType.keySet().toList();
+          }
+          
+          def HashMap<String, Multimap<EObject, EObject>> getOutgoingEdges(){
+                return outgoingEdges; 
+          }
+          
+          def HashMap<String, Multimap<EObject, EObject>> incomingEdges(){
+                return incomingEdges; 
+          }
+          
+}
+