1 files changed, 162 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.java
new file mode 100644
index 00000000..83bb92ca
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.java
@@ -0,0 +1,162 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph;
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.Graph;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric;
+import com.google.common.collect.Iterables;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialComplexTypeInterpretationImpl;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@SuppressWarnings("all")
+public class PartialInterpretationGraph extends Graph {
+  private final String typeToExclude = "undefinedpart";
+  
+  private final String classSuffix = " class";
+  
+  /**
+   * Define a new PartialInterpretationGraph by parse every element from a PartialInterpretation
+   */
+  public PartialInterpretationGraph(final PartialInterpretation partial, final List<Metric> metrics, final String name) {
+    final Consumer<RelationDeclaration> _function = (RelationDeclaration it) -> {
+      String n = it.getName().split(" ")[0];
+      this.statistic.addEdgeType(n);
+    };
+    Iterables.<RelationDeclaration>filter(partial.getProblem().getRelations(), RelationDeclaration.class).forEach(_function);
+    final Iterable<PartialComplexTypeInterpretationImpl> typeInterpretations = this.getTypes(partial);
+    for (final PartialComplexTypeInterpretationImpl type : typeInterpretations) {
+      boolean _isConcreteType = this.isConcreteType(type.getInterpretationOf());
+      if (_isConcreteType) {
+        String typeName = type.getInterpretationOf().getName().replace(this.classSuffix, "");
+        EList<DefinedElement> _elements = type.getElements();
+        for (final DefinedElement node : _elements) {
+          boolean _containsNode = this.statistic.containsNode(node);
+          boolean _not = (!_containsNode);
+          if (_not) {
+            this.statistic.addNodeWithType(node, typeName);
+          } else {
+            String currentType = ((String[])Conversions.unwrapArray(this.statistic.getTypesForNode(node), String.class))[0];
+            boolean _isSuperType = this.isSuperType(currentType, type.getInterpretationOf());
+            if (_isSuperType) {
+              this.statistic.overwriteCurrentType(node, typeName);
+            }
+          }
+        }
+      }
+    }
+    EList<PartialRelationInterpretation> _partialrelationinterpretation = partial.getPartialrelationinterpretation();
+    for (final PartialRelationInterpretation relationInterpretation : _partialrelationinterpretation) {
+      {
+        final String type_1 = relationInterpretation.getInterpretationOf().getName().split(" ")[0];
+        Iterable<BinaryElementRelationLink> _filter = Iterables.<BinaryElementRelationLink>filter(relationInterpretation.getRelationlinks(), BinaryElementRelationLink.class);
+        for (final BinaryElementRelationLink edge : _filter) {
+          this.statistic.addEdge(edge.getParam1(), edge.getParam2(), type_1);
+        }
+      }
+    }
+    this.name = name;
+    this.metrics = metrics;
+  }
+  
+  /**
+   * recursively check if a type is the super type of another
+   */
+  public boolean isSuperType(final String typeName, final Type subtypeToCheck) {
+    EList<Type> superTypes = subtypeToCheck.getSupertypes();
+    int _size = superTypes.size();
+    boolean _equals = (_size == 0);
+    if (_equals) {
+      return false;
+    } else {
+      final Function1<Type, String> _function = (Type it) -> {
+        return it.getName().replace(this.classSuffix, "");
+      };
+      boolean _contains = ListExtensions.<Type, String>map(subtypeToCheck.getSupertypes(), _function).contains(typeName);
+      if (_contains) {
+        return true;
+      } else {
+        for (final Type superType : superTypes) {
+          boolean _isSuperType = this.isSuperType(typeName, superType);
+          if (_isSuperType) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Check if a Type object is the class that we want to consider
+   *    A type object is to be considered if it satisfy one of the following:
+   *    1. if it is not abstract
+   *    2. if it is abstract but has a subclass of type TypeDefinition (This means the generation is
+   *       started with nodes in this type)
+   */
+  public boolean isConcreteType(final Type t) {
+    if (((!t.isIsAbstract()) || (IterableExtensions.<Type>findFirst(t.getSubtypes(), ((Function1<Type, Boolean>) (Type it) -> {
+      return Boolean.valueOf((it instanceof TypeDefinition));
+    })) != null))) {
+      return true;
+    }
+    return false;
+  }
+  
+  /**
+   * Set basic information for the output
+   */
+  @Override
+  public void setBasicInformation(final ArrayList<ArrayList<String>> output) {
+    final ArrayList<String> metaInfo = new ArrayList<String>();
+    metaInfo.add(Graph.META_MODEL_HEADER);
+    metaInfo.add(this.metaModel);
+    final ArrayList<String> edgeInfo = new ArrayList<String>();
+    edgeInfo.add(Graph.NUM_EDGE_TYPE_HEADER);
+    int _size = this.statistic.getAllTypes().size();
+    String _plus = (Integer.valueOf(_size) + "");
+    edgeInfo.add(_plus);
+    final ArrayList<String> nodeInfo = new ArrayList<String>();
+    nodeInfo.add(Graph.NUM_NODE_HEADER);
+    int _size_1 = this.statistic.getAllNodes().size();
+    String _plus_1 = (Integer.valueOf(_size_1) + "");
+    nodeInfo.add(_plus_1);
+    final ArrayList<String> stateInfo = new ArrayList<String>();
+    stateInfo.add(Graph.STATE_ID_HEADER);
+    stateInfo.add(this.name);
+    output.add(metaInfo);
+    output.add(edgeInfo);
+    output.add(nodeInfo);
+    output.add(stateInfo);
+  }
+  
+  private Iterable<PartialComplexTypeInterpretationImpl> getTypes(final PartialInterpretation partial) {
+    final Function1<PartialComplexTypeInterpretationImpl, Boolean> _function = (PartialComplexTypeInterpretationImpl it) -> {
+      boolean _contains = it.getInterpretationOf().getName().toLowerCase().contains(this.typeToExclude);
+      return Boolean.valueOf((!_contains));
+    };
+    return IterableExtensions.<PartialComplexTypeInterpretationImpl>filter(Iterables.<PartialComplexTypeInterpretationImpl>filter(partial.getPartialtypeinterpratation(), PartialComplexTypeInterpretationImpl.class), _function);
+  }
+  
+  @Override
+  public GraphStatistic getStatistic() {
+    throw new UnsupportedOperationException("TODO: auto-generated method stub");
+  }
+  
+  @Override
+  public String getName() {
+    return this.name;
+  }
+}