From f830b650e4ee22b38a8c1e19592e0959e26a503b Mon Sep 17 00:00:00 2001
From: Johannes Mey <johannes.mey@tu-dresden.de>
Date: Thu, 5 Apr 2018 14:46:42 +0200
Subject: [PATCH] refactoring of attributes

---
 .../src/main/jastadd/Imports.jadd             |   6 +-
 .../src/main/jastadd/Navigation.jrag          | 428 ++++++++----------
 .../src/main/jastadd/solvers/ilp/ILP.jrag     |  12 +-
 .../st/mquat/generator/ScenarioGenerator.java |  46 +-
 .../st/mquat/parser/MquatParserHelper.java    |  16 +-
 .../mquat/solving/HandwrittenTestSuite.java   |   6 +-
 6 files changed, 239 insertions(+), 275 deletions(-)

diff --git a/jastadd-mquat-base/src/main/jastadd/Imports.jadd b/jastadd-mquat-base/src/main/jastadd/Imports.jadd
index 2ab67fe..a6675f5 100644
--- a/jastadd-mquat-base/src/main/jastadd/Imports.jadd
+++ b/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 {
-
-  syn Set Clause.x() = null;
-}
\ No newline at end of file
+import java.util.Optional;
\ No newline at end of file
diff --git a/jastadd-mquat-base/src/main/jastadd/Navigation.jrag b/jastadd-mquat-base/src/main/jastadd/Navigation.jrag
index 0619a9e..5d48f24 100644
--- a/jastadd-mquat-base/src/main/jastadd/Navigation.jrag
+++ b/jastadd-mquat-base/src/main/jastadd/Navigation.jrag
@@ -28,123 +28,144 @@ aspect Navigation {
   eq Clause.getExpression().containingClause() = this;
   eq BinaryExpression.getLeft().containingClause() = containingClause();
   eq BinaryExpression.getRight().containingClause() = containingClause();
-  eq CurrentResourceValue.getValue().containingClause() = null;
-  eq MetaParameterAssignment.getLiteralExpression().containingClause() = null;
+  eq CurrentResourceValue.getValue().containingClause() {
+    throw new java.util.NoSuchElementException();
+  }
+  eq MetaParameterAssignment.getLiteralExpression().containingClause() {
+    throw new java.util.NoSuchElementException();
+  }
 
+  //--- containingResourceRequirement ---//
 
-  // downwards search ==================================================================================================
+  inh ResourceRequirement Instance.containingResourceRequirement();
+  eq ComponentRequirement.getInstance().containingResourceRequirement() = null;
+  eq ResourceRequirement.getInstance().containingResourceRequirement() = this;
+
+  //--- referringResourceType ---//
 
+  inh ResourceType Instance.referringResourceType();
+  eq ComponentRequirement.getInstance().referringResourceType() = null;
+  eq ResourceRequirement.getInstance().referringResourceType() = getResourceTypeRef().getRef();
+
+  //--- referringComponent ---//
+
+  inh Component Instance.referringComponent();
+  eq ComponentRequirement.getInstance(int i).referringComponent() = getComponentRef().getRef();
+  eq ResourceRequirement.getInstance(int i).referringComponent() = null;
 
-  //--- findRequestByName ---//
 
-  syn Request Root.findRequestByName(String name) {
+  // downwards search ==================================================================================================
+
+  // request
+
+  syn Optional<Request> Root.resolveRequest(String name) {
     for (Request request : getRequestList()) {
       if (request.name().equals(name)) {
-        return request;
+        return Optional.of(request);
       }
     }
-    throw new java.util.NoSuchElementException(name);
+    return Optional.empty();
   }
 
-  //--- findImplementationByName ---//
+  // property
 
-  syn Implementation Root.findImplementationByName(String name) {
-    for (Component component : getSoftwareModel().getComponentList()) {
-      for (Implementation impl : component.getImplementationList()) {
-        if (impl.name().equals(name)) {
-          return impl;
-        }
+  syn Optional<Property> ResourceType.resolveProperty(String name) {
+    for (Property property: getPropertyList()) {
+      if (property.name().equals(name)) {
+        return Optional.of(property);
       }
     }
-    throw new java.util.NoSuchElementException(name);
-  }
 
-  //--- findResourceByName ---//
+    for (PropertyRef ref: getPropertyRefList()) {
+      if (ref.getRef().name().equals(name)) {
+        return Optional.of(ref.getRef());
+      }
+    }
+    return Optional.empty();
+  }
 
-  syn Resource Root.findResourceByName(String name) {
-    for (Resource resource : getHardwareModel().getResourceList()) {
-      if (resource.findResourceByName(name) != null) {
-        return resource.findResourceByName(name);
+  syn Optional<Property> SoftwareModel.resolveProperty(String name) {
+    for (Property property: getPropertyList()) {
+      if (property.name().equals(name)) {
+        return Optional.of(property);
       }
     }
-    throw new java.util.NoSuchElementException(name);
+    return Optional.empty();
   }
 
-  syn Resource Resource.findResourceByName(String name) {
-    if (name().equals(name)) {
-      return this;
+  syn Optional<Property> Component.resolveProperty(String name) {
+    for (Property property : getPropertyList()) {
+      if (property.name().equals(name)) {
+        return Optional.of(property);
+      }
     }
-    for (Resource sub : getSubResourceList()) {
-      if (sub.findResourceByName(name) != null) {
-        return sub.findResourceByName(name);
+    for (PropertyRef ref : getPropertyRefList()) {
+      if (ref.name().equals(name)) {
+        return Optional.of(ref.getRef());
       }
     }
-    return null;
+    return resolvePropertyGeneral(name);
   }
 
-  //--- findInstanceByName ---//
+  inh Optional<Property> Component.resolvePropertyGeneral(String name);
 
-  syn Instance Implementation.findInstanceByName(String name) {
-    for (ComponentRequirement cr : getComponentRequirementList()) {
-      for (Instance instance : cr.getInstanceList()) {
-        if (instance.name().equals(name)) {
-          return instance;
-        }
-      }
-    }
-    for (Instance instance : getResourceRequirement().getInstanceList()) {
-      if (instance.name().equals(name)) {
-        return instance;
+  eq SoftwareModel.getComponent().resolvePropertyGeneral(String name) {
+    for (Property property : getPropertyList()) {
+      if (property.name().equals(name)) {
+        return Optional.of(property);
       }
     }
-    throw new java.util.NoSuchElementException(name);
+    return Optional.empty();
   }
 
-  syn Instance ResourceRequirement.findInstanceByName(String name) {
-    // search sub resource requirements
-    for (ResourceRequirement subRequirement : getResourceRequirementList()) {
-      for (Instance instance : subRequirement.getInstanceList()) {
-        if (instance.name().equals(name)) {
-          return instance;
+  // implementation
+
+  syn Optional<Implementation> Root.resolveImplementation(String name) {
+    for (Component component : getSoftwareModel().getComponentList()) {
+      for (Implementation impl : component.getImplementationList()) {
+        if (impl.name().equals(name)) {
+          return Optional.of(impl);
         }
       }
     }
-    throw new java.util.NoSuchElementException(name);
+    return Optional.empty();
   }
 
-  //--- findResourceTypeByName ---//
+  // resource
 
-  syn ResourceType HardwareModel.findResourceTypeByName(String name) {
-    for (ResourceType type: getResourceTypeList()) {
-      if (type.name().equals(name)) {
-        return type;
+  syn Optional<Resource> Root.resolveResource(String name) {
+    for (Resource resource : getHardwareModel().getResourceList()) {
+      if (resource.resolveResource(name).isPresent()) {
+        return resource.resolveResource(name);
       }
     }
-    throw new RuntimeException("Did not find resource type '" + name + "'");
+    return Optional.empty();
   }
 
-  //--- findSubResourceByName ---//
-
-  syn ResourceType ResourceType.findSubResourceTypeByName(String name) {
-    for (ResourceType sub: getSubTypeList()) {
-      if (sub.name().equals(name)) {
-        return sub;
+  syn Optional<Resource> Resource.resolveResource(String name) {
+    if (name().equals(name)) {
+      return Optional.of(this);
+    }
+    for (Resource sub : getSubResourceList()) {
+      Optional<Resource> result = sub.resolveResource(name);
+      if (result.isPresent()) {
+        return result;
       }
     }
-    throw new RuntimeException("Did not find sub-resource type '" + name + "'");
+    return Optional.empty();
   }
 
-  syn Resource Resource.findSubResourceByTypeName(String name) {
+  syn Optional<Resource> Resource.resolveResourceByTypeName(String name) {
     for (Resource sub: getSubResourceList()) {
       if (sub.getType().getRef().name().equals(name)) {
-        return sub;
+        return Optional.of(sub);
       }
     }
-    throw new RuntimeException("Did not find sub-resource '" + name + "'");
+    return Optional.empty();
   }
 
   syn java.util.List<Resource> Resource.findSubResourcesByTypeName(String name) {
-    java.util.List<Resource> result = new java.util.ArrayList<Resource>();
+    java.util.List<Resource> result = new java.util.ArrayList<>();
     for (Resource sub: getSubResourceList()) {
       if (sub.getType().getRef().name().equals(name)) {
         result.add(sub);
@@ -153,106 +174,81 @@ aspect Navigation {
     return result;
   }
 
+  // instance
 
-
-  //--- getPropertyByName ---//
-
-  syn Property ResourceType.findPropertyByName(String name) {
-    // TODO rename to resolveProperty
-    for (Property property: getPropertyList()) {
-      if (property.name().equals(name)) {
-        return property;
+  syn Optional<Instance> Implementation.resolveInstance(String name) {
+    for (ComponentRequirement cr : getComponentRequirementList()) {
+      for (Instance instance : cr.getInstanceList()) {
+        if (instance.name().equals(name)) {
+          return Optional.of(instance);
+        }
       }
     }
-
-    for (PropertyRef ref: getPropertyRefList()) {
-      if (ref.getRef().name().equals(name)) {
-        return ref.getRef();
+    for (Instance instance : getResourceRequirement().getInstanceList()) {
+      if (instance.name().equals(name)) {
+        return Optional.of(instance);
       }
     }
-    throw new RuntimeException("Did not find property '" + name + "'");
+    return Optional.empty();
   }
 
-  syn Property SoftwareModel.findPropertyByName(String name) {
-    for (Property property: getPropertyList()) {
-      if (property.name().equals(name)) {
-        return property;
+  syn Optional<Instance> ResourceRequirement.resolveInstance(String name) {
+    // search sub resource requirements
+    for (ResourceRequirement subRequirement : getResourceRequirementList()) {
+      for (Instance instance : subRequirement.getInstanceList()) {
+        if (instance.name().equals(name)) {
+          return Optional.of(instance);
+        }
       }
     }
-    throw new RuntimeException("Did not find property '" + name + "'");
+    return Optional.empty();
   }
 
-  //--- requirementClauses ---//
+  // resourceType
 
-  syn java.util.List<Clause> Implementation.requirementClauses() {
-    java.util.List<Clause> result = new java.util.ArrayList<>();
-    for (Clause clause : getClauseList()) {
-      if (clause.isRequiringClause()) {
-        result.add(clause);
+  syn Optional<ResourceType> HardwareModel.resolveResourceType(String name) {
+    for (ResourceType type: getResourceTypeList()) {
+      if (type.name().equals(name)) {
+        return Optional.of(type);
       }
     }
-    return result;
+    return Optional.empty();
   }
 
-  //--- allImplementations ---//
-
-  syn java.util.List<Implementation> Root.allImplementations() {
-    java.util.List<Implementation> result = new java.util.ArrayList<>();
-    for (Component component : this.getSoftwareModel().getComponents()) {
-      for (Implementation implementation : component.getImplementations()) {
-        result.add(implementation);
+  syn Optional<ResourceType> ResourceType.resolveResourceType(String name) {
+    for (ResourceType sub: getSubTypeList()) {
+      if (sub.name().equals(name)) {
+        return Optional.of(sub);
       }
     }
-    return result;
+    return Optional.empty();
   }
 
-  syn Clause Implementation.findFirstProvidingClause(Property property) {
+  // clause
+
+  syn Optional<Clause> Implementation.findFirstProvidingClause(Property property) {
     for (Clause clause : getClauseList()) {
       if (clause.getClauseType() != ClauseType.PROVIDING) continue;
       Designator designator = clause.getDesignator();
       if (designator.isSoftwareDesignator() && designator.asSoftwareDesignator().getPropertyRef().getRef().equals(property)) {
-        return clause;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Searches in all implementations of the required component for providing clauses.
-   */
-  syn java.util.List<Tuple<Implementation, Clause>> Clause.providingClausesOfRequiredComponent() {
-    java.util.List<Tuple<Implementation, Clause>> result = new java.util.ArrayList<>();
-    if (getDesignator().isSoftwareDesignator()) {
-      SoftwareDesignator swDesignator = getDesignator().asSoftwareDesignator();
-      Property prop = swDesignator.getPropertyRef().getRef();
-      if (swDesignator.hasInstanceRef()) {
-        Component reqComponent = getDesignator().asSoftwareDesignator().getInstanceRef().getRef().referringComponent();
-        for (Implementation reqImpl : reqComponent.getImplementationList()) {
-          // TODO maybe implement findFirstProvidingClause for Implementation
-          Clause providingClause = reqImpl.findFirstProvidingClause(prop);
-          if (providingClause != null) { result.add(new Tuple<>(reqImpl, providingClause)); }
-        }
+        return Optional.of(clause);
       }
     }
-    return result;
+    return Optional.empty();
   }
 
-  // name resolution ===================================================================================================
-
-
-
-  //--- resolveQualifiedName ---//
+  // designator
 
   inh Designator Clause.resolveQualifiedName(QualifiedName qn);
 
   eq Request.getConstraint().resolveQualifiedName(QualifiedName qn) {
-      // this designator refers either to a MetaParameter ...
-      MetaParameter meta = resolveMetaParameter(qn.getName(0).getName());
-      if (meta != null) {
-        return new MetaParameterDesignator(meta.createRef());
-      }
-      // ... or to a property of the target component
-      return new SoftwareDesignator(new Opt<>(), getTarget().getRef().resolveProperty(qn.getName(0).getName()).createRef());
+    // this designator refers either to a MetaParameter ...
+    Optional<MetaParameter> meta = resolveMetaParameter(qn.getName(0).getName());
+    if (meta.isPresent()) {
+      return new MetaParameterDesignator(meta.get().createRef());
+    }
+    // ... or to a property of the target component
+    return new SoftwareDesignator(new Opt<>(), getTarget().getRef().resolveProperty(qn.getName(0).getName()).get().createRef());
   }
 
   eq Implementation.getClause().resolveQualifiedName(QualifiedName qn) = resolveQualifiedName(qn);
@@ -260,14 +256,14 @@ aspect Navigation {
   syn Designator Implementation.resolveQualifiedName(QualifiedName qn) {
     if (qn.getNumName() == 1) {
       // we have a meta parameter or something in the current context
-      MetaParameter meta=resolveMetaParameter(qn.getName(0).getName());
-      if(meta!=null) {
-        return new MetaParameterDesignator(meta.createRef());
+      Optional<MetaParameter> meta = resolveMetaParameter(qn.getName(0).getName());
+      if(meta.isPresent()) {
+        return new MetaParameterDesignator(meta.get().createRef());
       }
       // else, interpret the property as a local one of the current component
       // this might cause an exception of the property can not be resolved
-      Property property=containingComponent().resolveProperty(qn.getName(0).getName());
-      return new SoftwareDesignator(new Opt<>(),property.createRef());
+      Optional<Property> property = containingComponent().resolveProperty(qn.getName(0).getName());
+      return new SoftwareDesignator(new Opt<>(),property.get().createRef());
     } else {
 
       // first, check if it is a component requirement
@@ -281,7 +277,7 @@ aspect Navigation {
             // now resolve property of the type of the instance. we know, the instance refers to a component.
             Component component=instance.referringComponent();
             return new SoftwareDesignator(new Opt<>(instance.createRef()),
-                component.resolveProperty(propertyName).createRef());
+                component.resolveProperty(propertyName).get().createRef());
           }
         }
       }
@@ -302,123 +298,80 @@ aspect Navigation {
                 currentInstance = instance;
               }
             }
-          }
         }
-      // now, currentRequirement refers to the final resource type
-      return new PropertyResourceDesignator(currentInstance.createRef(), currentRequirement.getResourceTypeRef().getRef().findPropertyByName(qn.getName(qn.getNumName()-1).getName()).createRef());
-    }
-  }
-
-  //--- resolveProperty ---//
-
-  syn Property Component.resolveProperty(String name) {
-    for (Property p : getPropertyList()) {
-      if (p.name().equals(name)) {
-        return p;
-      }
-    }
-    for (PropertyRef ref : getPropertyRefList()) {
-      if (ref.name().equals(name)) {
-        return ref.getRef();
       }
+      // now, currentRequirement refers to the final resource type
+      return new PropertyResourceDesignator(currentInstance.createRef(), currentRequirement.getResourceTypeRef().getRef().resolveProperty(qn.getName(qn.getNumName()-1).getName()).get().createRef());
     }
-    // TODO resolvePropertyGeneral should actually not be needed anymore (all properties must be def'ed in Component)
-    return resolvePropertyGeneral(name);
   }
 
-  //--- resolvePropertyGeneral ---//
-
-  inh Property Component.resolvePropertyGeneral(String name);
-
-  eq SoftwareModel.getComponent().resolvePropertyGeneral(String name) {
-    for (Property p : getPropertyList()) {
-      if (p.name().equals(name)) {
-        return p;
-      }
-    }
-    throw new RuntimeException("Property not found: " + name);
-  }
+  // metaparameter
 
   //--- resolveMetaParameter ---//
 
-  syn MetaParameter SoftwareModel.resolveMetaParameter(String name) {
+  syn Optional<MetaParameter> SoftwareModel.resolveMetaParameter(String name) {
     for (MetaParameter meta : getMetaParameterList()) {
       if (meta.name().equals(name)) {
-        return meta;
+        return Optional.of(meta);
       }
     }
-    // TODO maybe add a note here for unsuccessful resolving. or throw something?
-    return null;
+    return Optional.empty();
   }
 
-  inh MetaParameter Component.resolveMetaParameter(String name);
+  inh Optional<MetaParameter> Component.resolveMetaParameter(String name);
   eq SoftwareModel.getComponent().resolveMetaParameter(String name) = resolveMetaParameter(name);
 
-  inh MetaParameter Implementation.resolveMetaParameter(String name);
+  inh Optional<MetaParameter> Implementation.resolveMetaParameter(String name);
   eq Component.getImplementation().resolveMetaParameter(String name) = resolveMetaParameter(name);
 
-  inh MetaParameter Request.resolveMetaParameter(String name);
+  inh Optional<MetaParameter> Request.resolveMetaParameter(String name);
   eq Root.getRequest().resolveMetaParameter(String name) = getSoftwareModel().resolveMetaParameter(name);
 
 
-  //--- getRequiringClauseInstance ---//
+  // collections =======================================================================================================
 
-  syn Instance Implementation.getRequiringClauseInstance(ResourceType type, String propertyName) {
-    for (Clause clause: getClauseList()) {
-      Designator designator = clause.getDesignator();
-      if (clause.getClauseType() == ClauseType.REQUIRING
-              && designator.isPropertyResourceDesignator()
-              && designator.asPropertyResourceDesignator().getInstanceRef().getRef().referringResourceType().equals(type)
-              && designator.simpleName().equals(propertyName)) {
-          return designator.asPropertyResourceDesignator().getInstanceRef().getRef();
-      }
-    }
-    return null;
-  }
+  //--- requiy-crementClauses ---//
 
-  syn Instance Implementation.getRequiringClauseInstance(ResourceType type, String propertyName, int index) {
-    int i = 0;
-    for (Clause clause: getClauseList()) {
-      Designator designator = clause.getDesignator();
-      if (clause.getClauseType() == ClauseType.REQUIRING
-          && designator.isPropertyResourceDesignator()
-          && designator.asPropertyResourceDesignator().getInstanceRef().getRef().referringResourceType().equals(type)
-          && designator.simpleName().equals(propertyName)) {
-        if (i==index) {
-          return designator.asPropertyResourceDesignator().getInstanceRef().getRef();
-        } else {
-          i++;
-        }
+  syn java.util.List<Clause> Implementation.requirementClauses() {
+    java.util.List<Clause> result = new java.util.ArrayList<>();
+    for (Clause clause : getClauseList()) {
+      if (clause.isRequiringClause()) {
+        result.add(clause);
       }
     }
-    return null;
-  }
-
-
-
+    return result;
+    }
 
-  //--- containingResourceRequirement ---//
 
-  inh ResourceRequirement Instance.containingResourceRequirement();
-  eq ComponentRequirement.getInstance().containingResourceRequirement() {
-    throw new RuntimeException("There is no resource requirement for an instance of a component.");
+  syn java.util.List<Implementation> Root.allImplementations() {
+    java.util.List<Implementation> result = new java.util.ArrayList<>();
+    for (Component component : this.getSoftwareModel().getComponents()) {
+      for (Implementation implementation : component.getImplementations()) {
+        result.add(implementation);
+      }
+    }
+    return result;
   }
-  eq ResourceRequirement.getInstance().containingResourceRequirement() = this;
-
-  //--- referringResourceType ---//
 
-  inh ResourceType Instance.referringResourceType();
-  eq ComponentRequirement.getInstance().referringResourceType() {
-    throw new RuntimeException("There is no resource for an instance of a component.");
+  /**
+   * Searches in all implementations of the required component for providing clauses.
+   */
+  syn java.util.List<Tuple<Implementation, Clause>> Clause.providingClausesOfRequiredComponent() {
+    java.util.List<Tuple<Implementation, Clause>> result = new java.util.ArrayList<>();
+    if (getDesignator().isSoftwareDesignator()) {
+      SoftwareDesignator swDesignator = getDesignator().asSoftwareDesignator();
+      Property prop = swDesignator.getPropertyRef().getRef();
+      if (swDesignator.hasInstanceRef()) {
+        Component reqComponent = getDesignator().asSoftwareDesignator().getInstanceRef().getRef().referringComponent();
+        for (Implementation reqImpl : reqComponent.getImplementationList()) {
+          // TODO maybe implement findFirstProvidingClause for Implementation
+          Optional<Clause> providingClause = reqImpl.findFirstProvidingClause(prop);
+          if (providingClause.isPresent()) { result.add(new Tuple<>(reqImpl, providingClause.get())); }
+        }
+      }
+    }
+    return result;
   }
-  eq ResourceRequirement.getInstance().referringResourceType() = getResourceTypeRef().getRef();
-
-  //--- referringComponent ---//
-
-  inh Component Instance.referringComponent();
-  eq ComponentRequirement.getInstance(int i).referringComponent() = getComponentRef().getRef();
-  eq ResourceRequirement.getInstance(int i).referringComponent() = null;
-
 
   syn java.util.Collection<Component> Implementation.getRequiredComponents() {
     java.util.List<Component> result = new java.util.ArrayList();
@@ -522,5 +475,26 @@ aspect Navigation {
     throw new RuntimeException("Did not find a requiring clause for designator '" + propertyName + "'");
   }
 
+  syn Instance Implementation.getRequiringClauseInstance(ResourceType type, String propertyName) {
+    return getRequiringClauseInstance(type, propertyName, 0);
+  }
+
+  syn Instance Implementation.getRequiringClauseInstance(ResourceType type, String propertyName, int index) {
+    int i = 0;
+    for (Clause clause: getClauseList()) {
+      Designator designator = clause.getDesignator();
+      if (clause.getClauseType() == ClauseType.REQUIRING
+          && designator.isPropertyResourceDesignator()
+          && designator.asPropertyResourceDesignator().getInstanceRef().getRef().referringResourceType().equals(type)
+          && designator.simpleName().equals(propertyName)) {
+        if (i==index) {
+          return designator.asPropertyResourceDesignator().getInstanceRef().getRef();
+        } else {
+          i++;
+        }
+      }
+    }
+    return null;
+  }
 
 }
diff --git a/jastadd-mquat-base/src/main/jastadd/solvers/ilp/ILP.jrag b/jastadd-mquat-base/src/main/jastadd/solvers/ilp/ILP.jrag
index e7ca0cd..2cec654 100644
--- a/jastadd-mquat-base/src/main/jastadd/solvers/ilp/ILP.jrag
+++ b/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));
             }
           }
         }
diff --git a/jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/generator/ScenarioGenerator.java b/jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/generator/ScenarioGenerator.java
index 6588645..e05c6af 100644
--- a/jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/generator/ScenarioGenerator.java
+++ b/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);
diff --git a/jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/parser/MquatParserHelper.java b/jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/parser/MquatParserHelper.java
index 9a15ceb..efdac8b 100644
--- a/jastadd-mquat-base/src/main/java/de/tudresden/inf/st/mquat/parser/MquatParserHelper.java
+++ b/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);
     }
diff --git a/jastadd-mquat-solver/src/test/java/de/tudresden/inf/st/mquat/solving/HandwrittenTestSuite.java b/jastadd-mquat-solver/src/test/java/de/tudresden/inf/st/mquat/solving/HandwrittenTestSuite.java
index c519b14..13d6099 100644
--- a/jastadd-mquat-solver/src/test/java/de/tudresden/inf/st/mquat/solving/HandwrittenTestSuite.java
+++ b/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);
-- 
GitLab