refactoring of attributes

jastadd-mquat-base/src/main/jastadd/Imports.jadd

@@ -8,8 +8,4 @@ import java.util.HashMap;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.NoSuchElementException;
-
-aspect X {
+import java.util.Optional;
\ No newline at end of file
-
-  syn Set Clause.x() = null;
-}
\ No newline at end of file

jastadd-mquat-base/src/main/jastadd/solvers/ilp/ILP.jrag

@@ -72,9 +72,9 @@ aspect ILP {
             IlpTerm term = new IlpTerm();
             IlpVariable var = info.getIlpVariable(request, impl, resource);
             term.setRef(var);
-            Clause providingObjectiveClause = impl.findFirstProvidingClause(getObjective().getPropertyRef().getRef());
-            if (providingObjectiveClause != null) {
-              term.setValue(providingObjectiveClause.evalUsing(request, resource));
+            Optional<Clause> providingObjectiveClause = impl.findFirstProvidingClause(getObjective().getPropertyRef().getRef());
+            if (providingObjectiveClause.isPresent()) {
+              term.setValue(providingObjectiveClause.get().evalUsing(request, resource));
             } else {
               term.setValue(0);
             }
@@ -150,10 +150,10 @@ aspect ILP {
         Property requiredProperty = requiredClause.getDesignator().asSoftwareDesignator().getPropertyRef().getRef();
         for(Implementation impl : request.getTarget().getRef().getImplementationList()) {
           for (Resource resource : this.getHardwareModel().getResources()) {
-            Clause providingClause = impl.findFirstProvidingClause(requiredProperty);
-            if (providingClause != null) {
+            Optional<Clause> providingClause = impl.findFirstProvidingClause(requiredProperty);
+            if (providingClause.isPresent()) {
               IlpVariable var = info.getIlpVariable(request, impl, resource);
-              reqLhs.addIlpTerm(new IlpTerm(providingClause.evalUsing(request, resource), var));
+              reqLhs.addIlpTerm(new IlpTerm(providingClause.get().evalUsing(request, resource), var));
             }
           }
         }

jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/generator/ScenarioGenerator.java

@@ -237,12 +237,12 @@ public class ScenarioGenerator {
     ResourceType diskType = hardwareModel.diskType();
     ResourceType networkType = hardwareModel.networkType();
 
-    Property frequency = cpuType.findPropertyByName("frequency");
-    Property load = cpuType.findPropertyByName("load");
-    Property total = ramType.findPropertyByName("total");
-    Property free = ramType.findPropertyByName("free");
-    Property throughput = networkType.findPropertyByName("throughput");
-    Property latency = networkType.findPropertyByName("latency");
+    Property frequency = cpuType.resolveProperty("frequency").get();
+    Property load = cpuType.resolveProperty("load").get();
+    Property total = ramType.resolveProperty("total").get();
+    Property free = ramType.resolveProperty("free").get();
+    Property throughput = networkType.resolveProperty("throughput").get();
+    Property latency = networkType.resolveProperty("latency").get();
 
     // create a new resource
     Resource resource = new Resource(new Name("resource" + String.valueOf(i)), type.createRef(), new List<>(), new List<>());
@@ -288,22 +288,16 @@ public class ScenarioGenerator {
     model.getSoftwareModel().addComponent(component);
 
     // get the ResourceTypes we need
-    ResourceType cpu = model.getHardwareModel().findResourceTypeByName("ComputeNode").findSubResourceTypeByName("CPU");
-    ResourceType ram = model.getHardwareModel().findResourceTypeByName("ComputeNode").findSubResourceTypeByName("RAM");
-    ResourceType disk = model.getHardwareModel().findResourceTypeByName("ComputeNode").findSubResourceTypeByName("DISK");
-    ResourceType network = model.getHardwareModel().findResourceTypeByName("ComputeNode").findSubResourceTypeByName("NETWORK");
-
-    // get the properties we need
-    assert cpu != null;
-    assert ram != null;
-    assert network != null;
-    assert disk != null;
-
-    Property frequency = cpu.findPropertyByName("frequency");
-    Property total = ram.findPropertyByName("total");
-    Property throughput = network.findPropertyByName("throughput");
-    Property quality = model.getSoftwareModel().findPropertyByName("quality");
-    Property energy = model.getSoftwareModel().findPropertyByName("energy");
+    ResourceType cpu = model.getHardwareModel().resolveResourceType("ComputeNode").get().resolveResourceType("CPU").get();
+    ResourceType ram = model.getHardwareModel().resolveResourceType("ComputeNode").get().resolveResourceType("RAM").get();
+    ResourceType disk = model.getHardwareModel().resolveResourceType("ComputeNode").get().resolveResourceType("DISK").get();
+    ResourceType network = model.getHardwareModel().resolveResourceType("ComputeNode").get().resolveResourceType("NETWORK").get();
+
+    Property frequency = cpu.resolveProperty("frequency").get();
+    Property total = ram.resolveProperty("total").get();
+    Property throughput = network.resolveProperty("throughput").get();
+    Property quality = model.getSoftwareModel().resolveProperty("quality").get();
+    Property energy = model.getSoftwareModel().resolveProperty("energy").get();
 //    Property flops = model.getHardwareModel().getResourceType(0).getPropertyByName("flops");
 
     component.addPropertyRef(quality.createRef());
@@ -557,10 +551,10 @@ public class ScenarioGenerator {
     Root model = solution.getModel();
 
     ResourceType computeType = model.getHardwareModel().getResourceType(0);
-    ResourceType cpuType = model.getHardwareModel().getResourceType(0).findSubResourceTypeByName("CPU");
-    ResourceType ramType = model.getHardwareModel().getResourceType(0).findSubResourceTypeByName("RAM");
-    ResourceType diskType = model.getHardwareModel().getResourceType(0).findSubResourceTypeByName("DISK");
-    ResourceType networkType = model.getHardwareModel().getResourceType(0).findSubResourceTypeByName("NETWORK");
+    ResourceType cpuType = model.getHardwareModel().getResourceType(0).resolveResourceType("CPU").get();
+    ResourceType ramType = model.getHardwareModel().getResourceType(0).resolveResourceType("RAM").get();
+    ResourceType diskType = model.getHardwareModel().getResourceType(0).resolveResourceType("DISK").get();
+    ResourceType networkType = model.getHardwareModel().getResourceType(0).resolveResourceType("NETWORK").get();
 
     Assignment currentAssignment = new Assignment();
     currentAssignment.setTopLevel(isTopLevel);

jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/parser/MquatParserHelper.java

@@ -75,11 +75,11 @@ public class MquatParserHelper {
     Tuple<String, String> tuple = resourceMappingTerminals.get(rm);
     // first name in tuple is instance name
     // resolve instance using implementation of assignment
-    Instance instance = impl.findInstanceByName(tuple.getFirstElement());
+    Instance instance = impl.resolveInstance(tuple.getFirstElement()).get();
     rm.setInstance(instance);
     // second name in tuple is resource name
     // resolve top-level resource using model
-    Resource container = impl.root().findResourceByName(tuple.getSecondElement());
+    Resource container = impl.root().resolveResource(tuple.getSecondElement()).get();
     rm.setResource(container);
     ResourceRequirement rr = instance.containingResourceRequirement();
     for (ResourceMapping subResMapping : rm.getResourceMappingList()) {
@@ -91,10 +91,10 @@ public class MquatParserHelper {
     // resolve sub-resource using the top-level resource, and the corresponding resource requirement
     Tuple<String, String> tuple = resourceMappingTerminals.get(rm);
     // first name in tuple is instance name
-    Instance instance = rr.findInstanceByName(tuple.getFirstElement());
+    Instance instance = rr.resolveInstance(tuple.getFirstElement()).get();
     rm.setInstance(instance);
     // second name in tuple is resource name
-    Resource resource = container.findResourceByName(tuple.getSecondElement());
+    Resource resource = container.resolveResource(tuple.getSecondElement()).get();
     rm.setResource(resource);
     if (rm.getNumResourceMapping() > 0) {
       ResourceRequirement subResReq = instance.containingResourceRequirement();
@@ -116,10 +116,10 @@ public class MquatParserHelper {
     for (Assignment assignment : unfinishedSolution.getAssignmentList()) {
       Tuple<String, String> value = assignmentTerminals.get(assignment);
       // first name in value is request name
-      Request request = model.findRequestByName(value.getFirstElement());
+      Request request = model.resolveRequest(value.getFirstElement()).get();
       assignment.setRequest(request);
       // second name in value is impl name
-      Implementation impl = model.findImplementationByName(value.getSecondElement());
+      Implementation impl = model.resolveImplementation(value.getSecondElement()).get();
       assignment.setImplementation(impl);
       resolveResourceMappingOf(assignment);
     }
@@ -156,9 +156,9 @@ public class MquatParserHelper {
       ComponentMapping cm = assignment.containingComponentMapping();
       // to find correct instance, we need to start at implementation of parentAssignment
       parentAssignment = cm.containingAssignment();
-      cm.setInstance(parentAssignment.getImplementation().findInstanceByName(entry.getValue().getFirstElement()));
+      cm.setInstance(parentAssignment.getImplementation().resolveInstance(entry.getValue().getFirstElement()).get());
       // second name in value is name of impl
-      Implementation impl = model.findImplementationByName(entry.getValue().getSecondElement());
+      Implementation impl = model.resolveImplementation(entry.getValue().getSecondElement()).get();
       assignment.setImplementation(impl);
       resolveResourceMappingOf(assignment);
     }

jastadd-mquat-solver/src/test/java/de/tudresden/inf/st/mquat/solving/HandwrittenTestSuite.java

@@ -52,8 +52,8 @@ public abstract class HandwrittenTestSuite {
     Root model = modelAndSolution.getFirstElement();
     Assignment expectedAssignment = new Assignment();
     expectedAssignment.setRequest(model.getRequest(request));
-    expectedAssignment.setImplementation(model.findImplementationByName(impl));
-    expectedAssignment.setResourceMapping(new ResourceMapping(expectedAssignment.getImplementation().getResourceRequirement().getInstance(0), model.findResourceByName(resource), new List<>()));
+    expectedAssignment.setImplementation(model.resolveImplementation(impl).get());
+    expectedAssignment.setResourceMapping(new ResourceMapping(expectedAssignment.getImplementation().getResourceRequirement().getInstance(0), model.resolveResource(resource).get(), new List<>()));
     // check if assignment matches (partly) one listed in the solution
     Iterator<Assignment> assignmentIterator = modelAndSolution.getSecondElement().assignmentIterator();
     while (assignmentIterator.hasNext()) {
@@ -70,7 +70,7 @@ public abstract class HandwrittenTestSuite {
 
   private void assertComponentRequirement(Assignment requiringAssignment,
                                           String instanceName, Assignment expectedProvidingAssignment) {
-    Instance instance = requiringAssignment.getImplementation().findInstanceByName(instanceName);
+    Instance instance = requiringAssignment.getImplementation().resolveInstance(instanceName).get();
     Assignment actualProvidingAssignment = requiringAssignment.mappedAssignment(instance);
     Assert.assertEquals(String.format("Not matching assignment for %s", instanceName),
         expectedProvidingAssignment, actualProvidingAssignment);