Merge branch 'dev' into 'master'

Updating master with current development state.

Closes #20, #14, #18, and #15

See merge request !4

eraser-base/src/main/java/de/tudresden/inf/st/eraser/jastadd/model/TupleHSB.java

@@ -8,9 +8,9 @@ import java.util.Objects;
  * @author rschoene - Initial contribution
  */
 public class TupleHSB implements Cloneable {
-  public int hue;
-  public int saturation;
-  public int brightness;
+  private int hue;
+  private int saturation;
+  private int brightness;
   public static TupleHSB of(int hue, int saturation, int brightness) {
     TupleHSB result = new TupleHSB();
     result.hue = hue;
@@ -19,6 +19,30 @@ public class TupleHSB implements Cloneable {
     return result;
   }
 
+  public int getHue() {
+    return hue;
+  }
+
+  public int getSaturation() {
+    return saturation;
+  }
+
+  public int getBrightness() {
+    return brightness;
+  }
+
+  public TupleHSB withDifferentHue(int hue) {
+    return TupleHSB.of(hue, this.saturation, this.brightness);
+  }
+
+  public TupleHSB withDifferentSaturation(int saturation) {
+    return TupleHSB.of(this.hue, saturation, this.brightness);
+  }
+
+  public TupleHSB withDifferentBrightness(int brightness) {
+    return TupleHSB.of(this.hue, this.saturation, brightness);
+  }
+
   public String toString() {
     return String.format("%s,%s,%s", hue, saturation, brightness);
   }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/OpenHab2Importer.java

@@ -26,6 +26,7 @@ import java.util.stream.Collectors;
 public class OpenHab2Importer {
 
   protected static final String thingTypesUrl = "http://%s/rest/thing-types";
+  protected static final String thingTypeDetailUrl = "http://%s/rest/thing-types/%s";
   protected static final String channelTypeUrl = "http://%s/rest/channel-types";
   protected static final String thingsUrl = "http://%s/rest/things";
   protected static final String itemsUrl = "http://%s/rest/items";
@@ -41,7 +42,7 @@ public class OpenHab2Importer {
     nonDefaultChannelCategories = new HashSet<>();
   }
 
-  public Root importFrom(String host, int port) {
+  public OpenHAB2Model importFrom(String host, int port) {
     /*
     Plan:
     - requesting: thing-types, channel-types, things, items, links
@@ -57,7 +58,8 @@ public class OpenHab2Importer {
     mapper.registerModule(module);
 
     try {
-      Root model = Root.createEmptyRoot();
+      Root root = Root.createEmptyRoot();
+      OpenHAB2Model model = root.getOpenHAB2Model();
       ThingTypeData[] thingTypeList = mapper.readValue(makeURL(thingTypesUrl, hostAndPort), ThingTypeData[].class);
       logger.info("Read a total of {} thing type(s).", thingTypeList.length);
       update(model, thingTypeList);
@@ -78,19 +80,14 @@ public class OpenHab2Importer {
       logger.info("Read a total of {} link(s).", linkList.length);
       update(model, linkList);
 
-      // create empty MQTT root
-      MqttRoot mqttRoot = new MqttRoot();
-      mqttRoot.setHostByName(host);
-      model.setMqttRoot(mqttRoot);
-
-      // create empty Influx root
-      InfluxRoot influxRoot = InfluxRoot.createDefault();
-      influxRoot.setHostByName(host);
-      model.setInfluxRoot(influxRoot);
-
+      // get parameters of thing types
+      for (ThingType thingType : model.getThingTypeList()) {
+        ThingTypeData data = mapper.readValue(makeURL(thingTypeDetailUrl, hostAndPort, thingType.getID()), ThingTypeData.class);
+        update(thingType, data);
+      }
       return model;
     } catch (IOException e) {
-      e.printStackTrace();
+      logger.catching(e);
       return null;
     }
   }
@@ -99,7 +96,11 @@ public class OpenHab2Importer {
     return URI.create(String.format(formatUrlString, hostAndPort)).toURL();
   }
 
-  private void update(Root model, ThingTypeData[] thingTypeList) {
+  protected URL makeURL(String formatUrlString, String hostAndPort, String id) throws MalformedURLException {
+    return URI.create(String.format(formatUrlString, hostAndPort, id)).toURL();
+  }
+
+  private void update(OpenHAB2Model model, ThingTypeData[] thingTypeList) {
     for (ThingTypeData thingTypeData : thingTypeList) {
       ThingType thingType = new ThingType();
       thingType.setID(thingTypeData.UID);
@@ -109,7 +110,7 @@ public class OpenHab2Importer {
     }
   }
 
-  private void update(Root model, ChannelTypeData[] channelTypeList) {
+  private void update(OpenHAB2Model model, ChannelTypeData[] channelTypeList) {
     for (ChannelTypeData channelTypeData : channelTypeList) {
       ChannelType channelType = new ChannelType();
       channelType.setID(channelTypeData.UID);
@@ -162,7 +163,7 @@ public class OpenHab2Importer {
     }
   }
 
-  private void update(Root model, ThingData[] thingList) {
+  private void update(OpenHAB2Model model, ThingData[] thingList) {
     for (ThingData thingData : thingList) {
       Thing thing = new Thing();
       thing.setID(thingData.UID);
@@ -181,7 +182,7 @@ public class OpenHab2Importer {
     }
   }
 
-  private void update(Root model, AbstractItemData[] itemList) {
+  private void update(OpenHAB2Model model, AbstractItemData[] itemList) {
     List<Tuple<Group, GroupItemData>> groupsWithMembers = new ArrayList<>();
     List<Tuple<Group, GroupItemData>> groupsInGroups = new ArrayList<>();
     List<Tuple<Item, AbstractItemData>> itemsInGroups = new ArrayList<>();
@@ -234,11 +235,21 @@ public class OpenHab2Importer {
           }));
         }
         // if state is not set in openHAB, then use default state for the item
+        item.disableSendState();
         if (itemData.state.equals(NULL_STATE)) {
           item.setStateToDefault();
         } else {
           item.setStateFromString(itemData.state, false);
         }
+        item.enableSendState();
+        if (itemData.metadata != null) {
+          for (Map.Entry<String, MetaDataData> entry : itemData.metadata.entrySet()) {
+            logger.debug("Add metadata for namespace {}", entry.getKey());
+            for (Map.Entry<String, String> metaDataEntry : entry.getValue().config.entrySet()) {
+              item.addMetaData(new ItemMetaData(metaDataEntry.getKey(), metaDataEntry.getValue()));
+            }
+          }
+        }
         if (itemData.groupNames.size() > 0) {
           itemsInGroups.add(Tuple.of(item, itemData));
         } else {
@@ -288,15 +299,38 @@ public class OpenHab2Importer {
     }
   }
 
-  private void update(Root model, LinkData[] linkList) {
+  private void update(OpenHAB2Model model, LinkData[] linkList) {
     for (LinkData linkData : linkList) {
-      Link link = new Link();
       ifPresent(model.resolveChannel(linkData.channelUID), "Channel", linkData,
-          channel -> channel.addLink(link));
-      ifPresent(model.resolveItem(linkData.itemName), "Item", linkData, link::setItem);
+          channel -> ifPresent(model.resolveItem(linkData.itemName), "Item", linkData, channel::addLinkedItem));
     }
   }
 
+  private void update(ThingType thingType, ThingTypeData data) {
+    // just set parameters
+    if (data == null || data.configParameters == null) {
+      logger.warn("No parameters given for thing type {}", thingType.getID());
+      return;
+    }
+    for (ParameterData parameterData : data.configParameters) {
+      Parameter parameter = new Parameter();
+      parameter.setID(parameterData.name);
+      parameter.setLabel(parameterData.label);
+      parameter.setDescription(parameterData.description);
+      parameter.setContext(parameterData.context);
+      if (parameterData.defaultValue != null) {
+        parameter.setDefaultValue(new ParameterDefaultValue(parameterData.defaultValue));
+      }
+      parameter.setRequired(parameterData.required);
+      parameter.setType(ParameterValueType.valueOf(titleCase(parameterData.type)));
+      thingType.addParameter(parameter);
+    }
+  }
+
+  private String titleCase(String type) {
+    return Character.toTitleCase(type.charAt(0)) + type.substring(1).toLowerCase();
+  }
+
   @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
   private <T> void ifPresent(Optional<T> opt, String type, Object data,
                              Consumer<? super T> consumer) {
@@ -307,7 +341,7 @@ public class OpenHab2Importer {
     }
   }
 
-  public Root importFrom(URL baseUrl) {
+  public OpenHAB2Model importFrom(URL baseUrl) {
     return importFrom(baseUrl.getHost(),
         baseUrl.getPort() == -1 ? baseUrl.getDefaultPort() : baseUrl.getPort());
   }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/data/AbstractItemData.java

@@ -3,6 +3,7 @@ package de.tudresden.inf.st.eraser.openhab2.data;
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * Abstract JSON return type for either an item or a group in openHAB 2.
@@ -23,4 +24,5 @@ public class AbstractItemData {
   public String transformedState;
   public StateDescriptionData stateDescription;
   public Boolean editable;
+  public Map<String, MetaDataData> metadata;
 }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/data/MetaDataData.java

+package de.tudresden.inf.st.eraser.openhab2.data;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import java.util.Map;
+
+/**
+ * Item Meta data.
+ *
+ * @author rschoene - Initial contribution
+ */
+@SuppressWarnings("unused")
+@JsonInclude(JsonInclude.Include.NON_DEFAULT)
+public class MetaDataData {
+  public String value;
+  public Map<String, String> config;
+}

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/data/ParameterData.java

@@ -9,7 +9,7 @@ import java.util.List;
  *
  * @author rschoene - Initial contribution
  */
-@SuppressWarnings("unused")
+//@SuppressWarnings("unused")
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public class ParameterData {
   public String context;
@@ -19,24 +19,24 @@ public class ParameterData {
   public String name;
   public Boolean required;
   public String type;
-  public Integer min;
+//  public Integer min;
   public Integer max;
-  public Integer stepsize;
+//  public Integer stepsize;
   public String pattern;
   public Boolean readOnly;
-  public Boolean multiple;
-  public Integer multipleLimit;
-  public String groupName;
-  public Boolean advanced;
-  public Boolean verify;
-  public Boolean limitToOptions;
+//  public Boolean multiple;
+//  public Integer multipleLimit;
+//  public String groupName;
+//  public Boolean advanced;
+//  public Boolean verify;
+//  public Boolean limitToOptions;
   public String unit;
-  public String unitLabel;
-  public List<OptionData> options;
-  public List<FilterCriteriaData> filterCriteria;
+//  public String unitLabel;
+//  public List<OptionData> options;
+//  public List<FilterCriteriaData> filterCriteria;
 
-  public static class FilterCriteriaData {
-    public String name;
-    public String value;
-  }
+//  public static class FilterCriteriaData {
+//    public String name;
+//    public String value;
+//  }
 }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/data/ThingTypeData.java

@@ -19,4 +19,5 @@ public class ThingTypeData {
   public boolean listed;
   public List<String> supportedBridgeTypeUIDs;
   public boolean bridge;
+  public List<ParameterData> configParameters;
 }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/openhab2/mqtt/MQTTUpdater.java

 package de.tudresden.inf.st.eraser.openhab2.mqtt;
 
+import de.tudresden.inf.st.eraser.jastadd.model.ExternalHost;
 import de.tudresden.inf.st.eraser.jastadd.model.Item;
 import de.tudresden.inf.st.eraser.jastadd.model.Root;
 import de.tudresden.inf.st.eraser.util.MqttReceiver;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.fusesource.hawtbuf.Buffer;
-import org.fusesource.hawtbuf.UTF8Buffer;
-import org.fusesource.mqtt.client.*;
+import org.fusesource.mqtt.client.QoS;
 
 import java.io.IOException;
-import java.net.URI;
-import java.util.Arrays;
-import java.util.Objects;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Update an imported model by subscribing to MQTT topics.
@@ -36,29 +28,34 @@ public class MQTTUpdater implements AutoCloseable {
     this.delegatee = new MqttReceiver();
   }
 
-  public MQTTUpdater(Root model) throws IllegalArgumentException {
+  public MQTTUpdater(Root root) throws IllegalArgumentException {
     this();
-    this.setModel(model);
+    this.setRoot(root);
   }
 
   /**
-   * Sets the model to update
-   * @param model the model to update
+   * Sets the model root to update
+   * @param root the model root to update
    */
-  public void setModel(Root model) {
-    delegatee.setHost(model.getMqttRoot().getHost().getHostName());
+  public void setRoot(Root root) {
+    ExternalHost host = root.getMqttRoot().getHost();
+    delegatee.setHost(host.getHostName(), host.getPort());
     delegatee.setOnMessage((topicString, message) ->
-        model.getMqttRoot().resolveTopic(topicString).ifPresent(topic ->
-            itemUpdate(topic.getItem(), message)));
-    delegatee.setTopicsForSubscription(model.getMqttRoot().getIncomingPrefix() + "#");
+        root.getMqttRoot().resolveTopic(topicString).ifPresent(topic ->
+            topic.getItems().forEach(
+                item -> itemUpdate(item, message))));
+    delegatee.setTopicsForSubscription(root.getMqttRoot().getIncomingPrefix() + "#");
     delegatee.setQoSForSubscription(QoS.AT_LEAST_ONCE);
   }
 
   private void itemUpdate(Item item, String state) {
+    String oldState = item.getStateAsString();
+    if (oldState == null || !oldState.equals(state)) {
       this.logger.debug("Update state of {} [{}] from '{}' to '{}'.",
-        item.getLabel(), item.getID(), item.getStateAsString(), state);
+          item.getLabel(), item.getID(), oldState, state);
       item.setStateFromString(state, false);
     }
+  }
 
   /**
    * Waits until this updater is ready to receive MQTT messages.

eraser-base/src/main/java/de/tudresden/inf/st/eraser/parser/EraserParserHelper.java

 package de.tudresden.inf.st.eraser.parser;
 
 import de.tudresden.inf.st.eraser.jastadd.model.*;
+import de.tudresden.inf.st.eraser.util.JavaUtils;
 import de.tudresden.inf.st.eraser.util.ParserUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -28,9 +29,11 @@ public class EraserParserHelper {
   private Map<Channel, String> missingChannelTypeMap = new HashMap<>();
   private Map<Item, String> missingTopicMap = new HashMap<>();
   private Map<Item, String> missingItemCategoryMap = new HashMap<>();
+  private Map<Designator, String> missingItemForDesignator = new HashMap<>();
 
   private Map<Thing, Iterable<String>> missingChannelListMap = new HashMap<>();
   private Map<Channel, Iterable<String>> missingItemLinkListMap = new HashMap<>();
+  private Map<Item, Iterable<String>> missingControllingListMap = new HashMap<>();
   private Map<Group, Iterable<String>> missingSubGroupListMap = new HashMap<>();
   private Map<Group, Iterable<String>> missingItemListMap = new HashMap<>();
   private Map<ThingType, Iterable<String>> missingChannelTypeListMap = new HashMap<>();
@@ -44,6 +47,7 @@ public class EraserParserHelper {
   private Root root;
 
   private static boolean checkUnusedElements = true;
+  private static Root initialRoot = null;
 
   private class ItemPrototype extends DefaultItem {
 
@@ -57,25 +61,41 @@ public class EraserParserHelper {
     EraserParserHelper.checkUnusedElements = checkUnusedElements;
   }
 
+  public static void setInitialRoot(Root root) {
+    EraserParserHelper.initialRoot = root;
+  }
+
   /**
    * Post processing step after parsing a model, to resolve all references within the model.
-   * @throws java.util.NoSuchElementException if a reference can not be resolved
    */
   public void resolveReferences() {
+    if (this.root == null) {
+      // when parsing expressions
+      this.root = EraserParserHelper.initialRoot != null ? EraserParserHelper.initialRoot : createRoot();
+    }
     if (checkUnusedElements) {
       fillUnused();
     }
     resolve(thingTypeMap, missingThingTypeMap, Thing::setType);
     resolve(channelTypeMap, missingChannelTypeMap, Channel::setType);
+    if (itemMap == null || itemMap.isEmpty()) {
+      missingItemForDesignator.forEach((designator, itemName) ->
+          JavaUtils.ifPresentOrElse(root.getOpenHAB2Model().resolveItem(itemName),
+              designator::setItem,
+              () -> logger.warn("Could not resolve item {} for {}", itemName, designator)));
+    } else {
+      resolve(itemMap, missingItemForDesignator, Designator::setItem);
+    }
     missingTopicMap.forEach((topic, parts) -> ParserUtils.createMqttTopic(topic, parts, this.root));
     this.root.getMqttRoot().ensureCorrectPrefixes();
 
     resolveList(channelMap, missingChannelListMap, Thing::addChannel);
-    resolveList(itemMap, missingItemLinkListMap, (channel, item) -> channel.addLink(new Link(item)));
+    resolveList(itemMap, missingItemLinkListMap, Channel::addLinkedItem);
     resolveList(groupMap, missingSubGroupListMap, Group::addGroup);
     resolveList(itemMap, missingItemListMap, this::addItemToGroup);
     resolveList(channelTypeMap, missingChannelTypeListMap, ThingType::addChannelType);
     resolveList(parameterMap, missingParameterListMap, ThingType::addParameter);
+    resolveList(itemMap, missingControllingListMap, Item::addControlling);
 
     createUnknownGroupIfNecessary();
     createChannelCategories();
@@ -87,7 +107,7 @@ public class EraserParserHelper {
 
   private void addItemToGroup(Group group, Item item) {
     groupedItems.add(item);
-    group.getItemList().insertChild(item, 0);
+    group.addItem(item);
   }
 
   private void fillUnused() {
@@ -112,13 +132,13 @@ public class EraserParserHelper {
           sortedDanglingItems.add(item);
         }
       }
-      ParserUtils.createUnknownGroup(this.root, sortedDanglingItems);
+      ParserUtils.createUnknownGroup(this.root.getOpenHAB2Model(), sortedDanglingItems);
     }
   }
 
   private void createChannelCategories() {
     channelCategoryMap.values().stream().sorted(Comparator.comparing(this::ident)).forEach(
-        cc -> root.addChannelCategory(cc));
+        cc -> root.getOpenHAB2Model().addChannelCategory(cc));
     channelCategoryMap.clear();
   }
 
@@ -126,6 +146,7 @@ public class EraserParserHelper {
     Map<String, ItemCategory> newCategories = new HashMap<>();
     missingItemCategoryMap.forEach((item, category) ->
         item.setCategory(newCategories.computeIfAbsent(category, ItemCategory::new)));
+    newCategories.values().forEach(node -> root.getOpenHAB2Model().addItemCategory(node));
   }
 
   private void checkUnusedElements() {
@@ -136,7 +157,7 @@ public class EraserParserHelper {
     if (elem instanceof ModelElement) {
       return ((ModelElement) elem).getID();
     } else if (elem instanceof MqttTopic) {
-      return safeAllParts((MqttTopic) elem);
+      return ((MqttTopic) elem).getTopicString();
     } else if (elem instanceof DefaultChannelCategory) {
       return ((DefaultChannelCategory) elem).getValue().name();
     } else if (elem instanceof SimpleChannelCategory) {
@@ -145,41 +166,23 @@ public class EraserParserHelper {
     return elem.toString();
   }
 
-  private String safeAllParts(MqttTopic elem) {
-    StringBuilder sb = new StringBuilder(elem.getPart());
-    ASTNode parent;
-    while (true) {
-      parent = elem.getParent();
-      if (parent == null) break;
-      assert parent instanceof List;
-      parent = parent.getParent();
-      if (parent == null || parent instanceof MqttRoot) {
-        break;
-      }
-      elem = (MqttTopic) parent;
-      sb.insert(0, elem.getPart() + "/");
-    }
-    return sb.toString();
+  private <Src extends ASTNode, Target extends ASTNode> void resolveList(
+      Map<String, Target> resolved, Map<Src, Iterable<String>> missing, BiConsumer<Src, Target> adder) {
+    missing.forEach(
+        (elem, keyList) -> keyList.forEach(
+            key -> resolve0(resolved, key, elem, adder)));
+    missing.clear();
   }
 
-  private <Src extends ASTNode, Target extends ASTNode> void resolveList(Map<String, Target> resolved, Map<Src, Iterable<String>> missing, BiConsumer<Src, Target> adder) {
-    missing.forEach((elem, keyList) -> keyList.forEach(key -> {
-      Target value = resolved.get(key);
-      if (value == null) {
-        logger.warn("Reference in {} {} for '{}' cannot be resolved",
-            elem.getClass().getSimpleName(), ident(elem), key);
-        return;
-      }
-      if (checkUnusedElements) {
-        unusedElements.remove(value);
-      }
-      adder.accept(elem, value);
-    }));
+  private <Src extends ASTNode, Target extends ASTNode> void resolve(
+      Map<String, Target> resolved, Map<Src, String> missing, BiConsumer<Src, Target> setter) {
+    missing.forEach(
+        (elem, key) -> resolve0(resolved, key, elem, setter));
     missing.clear();
   }
 
-  private <Src extends ASTNode, Target extends ASTNode> void resolve(Map<String, Target> resolved, Map<Src, String> missing, BiConsumer<Src, Target> setter) {
-    missing.forEach((elem, key) -> {
+  private <Src extends ASTNode, Target extends ASTNode> void resolve0(
+      Map<String, Target> resolved, String key, Src elem, BiConsumer<Src, Target> action) {
     Target value = resolved.get(key);
     if (value == null) {
       logger.warn("Reference in {} {} for '{}' cannot be resolved",
@@ -189,29 +192,47 @@ public class EraserParserHelper {
     if (checkUnusedElements) {
       unusedElements.remove(value);
     }
-      setter.accept(elem, value);
-    });
-    missing.clear();
+    action.accept(elem, value);
   }
 
+  //--- Thing and ThingType ---
+
   public Thing addThingType(Thing t, String typeName) {
     missingThingTypeMap.put(t, typeName);
     return t;
   }
 
-  public ChannelType setItemType(ChannelType ct, String itemTypeName) {
-    ct.setItemType(ItemType.valueOf(itemTypeName));
-    return ct;
+  public ThingType setChannelTypes(ThingType tt, StringList channelTypeNames) {
+    missingChannelTypeListMap.put(tt, channelTypeNames);
+    return tt;
   }
 
-  public Item setCategory(Item item, String categoryName) {
-    missingItemCategoryMap.put(item, categoryName);
-    return item;
+  public ThingType setParameters(ThingType tt, StringList parameterNames) {
+    missingParameterListMap.put(tt, parameterNames);
+    return tt;
   }
 
-  public Item setTopic(Item item, String mqttTopicName) {
-    missingTopicMap.put(item, mqttTopicName);
-    return item;
+  public Thing setChannels(Thing t, StringList channelNames) {
+    missingChannelListMap.put(t, channelNames);
+    return t;
+  }
+
+  public Thing setID(Thing thing, String id) {
+    thing.setID(id);
+    return thing;
+  }
+
+  public ThingType setID(ThingType thingType, String id) {
+    thingType.setID(id);
+    thingTypeMap.put(id, thingType);
+    return thingType;
+  }
+
+  //--- Channel and ChannelType ---
+
+  public ChannelType setItemType(ChannelType ct, String itemTypeName) {
+    ct.setItemType(ItemType.valueOf(itemTypeName));
+    return ct;
   }
 
   public ChannelType setChannelCategory(ChannelType ct, String name) {
@@ -229,6 +250,95 @@ public class EraserParserHelper {
     return ct;
   }
 
+  public Channel setChannelType(Channel c, String channelTypeName) {
+    missingChannelTypeMap.put(c, channelTypeName);
+    return c;
+  }
+
+  public Channel setLinks(Channel c, StringList linkNames) {
+    missingItemLinkListMap.put(c, linkNames);
+    return c;
+  }
+
+  public ChannelType setID(ChannelType channelType, String id) {
+    channelType.setID(id);
+    channelTypeMap.put(id, channelType);
+    return channelType;
+  }
+
+  public Channel setID(Channel channel, String id) {
+    channel.setID(id);
+    channelMap.put(id, channel);
+    return channel;
+  }
+
+  //--- Item ---
+
+  public Item createItem() {
+    ItemPrototype result = new ItemPrototype();
+    result.disableSendState();
+    return result;
+  }
+
+  public Item setCategory(Item item, String categoryName) {
+    missingItemCategoryMap.put(item, categoryName);
+    return item;
+  }
+
+  public Item setMetaData(Item item, StringKeyMap metaData) {
+    for (AbstractMap.SimpleEntry<String, String> entry : metaData) {
+      item.addMetaData(new ItemMetaData(entry.getKey(), entry.getValue()));
+    }
+    return item;
+  }
+
+  public Item setControlling(Item item, StringList controlling) {
+    missingControllingListMap.put(item, controlling);
+    return item;
+  }
+
+  public Item retype(Item itemWithCorrectType, Item prototype) {
+    itemWithCorrectType.setID(prototype.getID());
+    itemWithCorrectType.setLabel(prototype.getLabel());
+    itemWithCorrectType.setMetaDataList(prototype.getMetaDataList());
+    if (!(itemWithCorrectType instanceof ActivityItem)) {
+      String state = prototype.getStateAsString();
+      itemWithCorrectType.disableSendState();
+      if (state.isEmpty()) {
+        itemWithCorrectType.setStateToDefault();
+      } else {
+        itemWithCorrectType.setStateFromString(state);
+      }
+      itemWithCorrectType.enableSendState();
+    }
+
+    moveMissingForRetype(itemWithCorrectType, prototype, missingTopicMap);
+    moveMissingForRetype(itemWithCorrectType, prototype, missingControllingListMap);
+    moveMissingForRetype(itemWithCorrectType, prototype, missingItemCategoryMap);
+
+    itemMap.put(prototype.getID(), itemWithCorrectType);
+
+    itemOrder.add(itemWithCorrectType);
+
+    return itemWithCorrectType;
+  }
+
+  private <T> void moveMissingForRetype(Item itemWithCorrectType, Item prototype, Map<Item, T> missingXMap) {
+    T value = missingXMap.get(prototype);
+    if (value != null) {
+      missingXMap.put(itemWithCorrectType, value);
+    }
+    missingXMap.remove(prototype);
+  }
+
+  public Item setID(Item item, String id) {
+    item.setID(id);
+    itemMap.put(id, item);
+    return item;
+  }
+
+  //--- Group ---
+
   public Group setSubGroups(Group g, StringList subGroupNames) {
     missingSubGroupListMap.put(g, subGroupNames);
     return g;
@@ -252,10 +362,8 @@ public class EraserParserHelper {
     params.iterator().forEachRemaining(paramList::add);
     String param1, param2;
     if (paramList.size() == 2) {
-      // ATTENTION: Here the order is reversed, as the parser reads from back to front
-      // So assign first parameter to second read parameter, and vice versa
-      param1 = paramList.get(1);
-      param2 = paramList.get(0);
+      param1 = paramList.get(0);
+      param2 = paramList.get(1);
     } else {
       logger.error("Got {} instead of 2 parameters in group function {}!", paramList.size(), aggFunctionName);
       param1 = "?";
@@ -265,77 +373,77 @@ public class EraserParserHelper {
     return g;
   }
 
-  public ThingType setChannelTypes(ThingType tt, StringList channelTypeNames) {
-    missingChannelTypeListMap.put(tt, channelTypeNames);
-    return tt;
+  public Group setID(Group group, String id) {
+    group.setID(id);
+    groupMap.put(id, group);
+    return group;
   }
 
+  //--- Parameter ---
+
   public Parameter setParameterValueType(Parameter p, String pvt) {
-    p.setType(ParameterValueType.valueOf(toTitleCase(pvt)));
+    p.setType(ParameterValueType.valueOf(JavaUtils.toTitleCase(pvt)));
     return p;
   }
 
-  private String toTitleCase(String s) {
-    if (s == null || s.isEmpty()) {
-      return s;
-    }
-    return s.substring(0, 1).toUpperCase() + s.substring(1);
-  }
-
   public Parameter setDefault(Parameter p, String defaultValue) {
     p.setDefaultValue(new ParameterDefaultValue(defaultValue));
     return p;
   }
 
-  public ThingType setParameters(ThingType tt, StringList parameterNames) {
-    missingParameterListMap.put(tt, parameterNames);
-    return tt;
+  public Parameter setID(Parameter parameter, String id) {
+    parameter.setID(id);
+    parameterMap.put(id, parameter);
+    return parameter;
   }
 
-  public Thing setChannels(Thing t, StringList channelNames) {
-    missingChannelListMap.put(t, channelNames);
-    return t;
-  }
+  //--- MQTT ---
 
-  public Channel setChannelType(Channel c, String channelTypeName) {
-    missingChannelTypeMap.put(c, channelTypeName);
-    return c;
+  public Item setTopic(Item item, String mqttTopicName) {
+    missingTopicMap.put(item, mqttTopicName);
+    return item;
   }
 
-  public Channel setLinks(Channel c, StringList linkNames) {
-    missingItemLinkListMap.put(c, linkNames);
-    return c;
+  //--- Activity ---
+
+  public MachineLearningRoot setActivities(MachineLearningRoot mlr, IntegerKeyMap map) {
+    for (AbstractMap.SimpleEntry<Integer, String> entry : map) {
+      Activity activity = new Activity();
+      activity.setIdentifier(entry.getKey());
+      activity.setLabel(entry.getValue());
+      mlr.addActivity(activity);
+    }
+    return mlr;
   }
 
+  //--- Root ---
+
   public Root createRoot() {
-    this.root = new Root();
-    this.root.setMqttRoot(new MqttRoot());
-    this.root.setInfluxRoot(InfluxRoot.createDefault());
-    this.root.setMachineLearningRoot(new MachineLearningRoot());
+    this.root = Root.createEmptyRoot();
     return this.root;
   }
 
   public Root createRoot(Thing t) {
     Root result = createRoot();
-    result.addThing(t);
+    result.getOpenHAB2Model().addThing(t);
     return result;
   }
 
   public Root createRoot(Group g) {
     Root result = createRoot();
-    result.addGroup(g);
+    result.getOpenHAB2Model().addGroup(g);
     return result;
   }
 
   public Root createRoot(ThingType tt) {
     Root result = createRoot();
-    result.addThingType(tt);
+    result.getOpenHAB2Model().addThingType(tt);
     return result;
   }
 
   public Root createRoot(ChannelType ct) {
     Root result = createRoot();
-    result.addChannelType(ct);
+    result.getOpenHAB2Model().addChannelType(ct);
     return result;
   }
 
@@ -351,64 +459,30 @@ public class EraserParserHelper {
     return result;
   }
 
-  public Item createItem() {
-    return new ItemPrototype();
-  }
-
-  public Item retype(Item itemWithCorrectType, Item prototype) {
-    itemWithCorrectType.setID(prototype.getID());
-    itemWithCorrectType.setLabel(prototype.getLabel());
-    itemWithCorrectType.setStateFromString(prototype.getStateAsString());
-
-    missingTopicMap.put(itemWithCorrectType, missingTopicMap.get(prototype));
-    missingTopicMap.remove(prototype);
-
-    itemMap.put(prototype.getID(), itemWithCorrectType);
-
-    itemOrder.add(itemWithCorrectType);
-
-    return itemWithCorrectType;
-  }
-
-  public Thing setID(Thing thing, String id) {
-    thing.setID(id);
-    return thing;
-  }
-
-  public Item setID(Item item, String id) {
-    item.setID(id);
-    itemMap.put(id, item);
-    return item;
-  }
-
-  public Group setID(Group group, String id) {
-    group.setID(id);
-    groupMap.put(id, group);
-    return group;
-  }
-
-  public ThingType setID(ThingType thingType, String id) {
-    thingType.setID(id);
-    thingTypeMap.put(id, thingType);
-    return thingType;
+  public Root createRoot(MachineLearningRoot ml) {
+    Root result = createRoot();
+    result.setMachineLearningRoot(ml);
+    return result;
   }
 
-  public Parameter setID(Parameter parameter, String id) {
-    parameter.setID(id);
-    parameterMap.put(id, parameter);
-    return parameter;
+  public Root createRoot(Rule rule) {
+    Root result = createRoot();
+    result.addRule(rule);
+    return result;
   }
 
-  public ChannelType setID(ChannelType channelType, String id) {
-    channelType.setID(id);
-    channelTypeMap.put(id, channelType);
-    return channelType;
+  //+++ newStuff (to be categorized) +++
+  public Designator createDesignator(String itemName) {
+    Designator result = new Designator();
+    missingItemForDesignator.put(result, itemName);
+    return result;
   }
 
-  public Channel setID(Channel channel, String id) {
-    channel.setID(id);
-    channelMap.put(id, channel);
-    return channel;
+  public Rule createRule(Condition c, Action a) {
+    Rule result = new Rule();
+    result.addCondition(c);
+    result.addAction(a);
+    return result;
   }
 
 }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/JavaUtils.java

@@ -45,4 +45,11 @@ public class JavaUtils {
     return StreamSupport.stream(jastAddList.spliterator(), false);
   }
 
+  public static String toTitleCase(String s) {
+    if (s == null || s.isEmpty()) {
+      return s;
+    }
+    return s.substring(0, 1).toUpperCase() + s.substring(1);
+  }
+
 }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/MemberPrinter.java

+package de.tudresden.inf.st.eraser.util;
+
+import de.tudresden.inf.st.eraser.jastadd.model.ASTNode;
+import de.tudresden.inf.st.eraser.jastadd.model.ModelElement;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * Fluent API to pretty-print ASTNodes in a line-based fashion.
+ *
+ * @author rschoene - Initial contribution
+ */
+public class MemberPrinter {
+
+  private static final Logger logger = LogManager.getLogger(MemberPrinter.class);
+  private static boolean addSemicolonNewlineWhenBuild = true;
+  private static boolean emitNothingOnEmptyBody = true;
+  private boolean empty = true;
+  private final StringBuilder sb;
+
+  public enum ListBracketType {
+    SQUARE("[", "]"),
+    ROUND("(", ")"),
+    CURLY("{", "}");
+
+    private final String begin;
+    private final String end;
+
+    ListBracketType(String begin, String end) {
+      this.begin = begin;
+      this.end = end;
+    }
+  }
+
+  public MemberPrinter(String elementName) {
+    this.sb = new StringBuilder();
+    if (elementName != null && !elementName.isEmpty()) {
+      sb.append(elementName).append(":");
+    }
+  }
+
+  public static void setAddSemicolonNewlineWhenBuild(boolean addSemicolonNewlineWhenBuild) {
+    MemberPrinter.addSemicolonNewlineWhenBuild = addSemicolonNewlineWhenBuild;
+  }
+
+  public static void setEmitNothingOnEmptyBody(boolean emitNothingOnEmptyBody) {
+    MemberPrinter.emitNothingOnEmptyBody = emitNothingOnEmptyBody;
+  }
+
+  public String build() {
+    if (empty) {
+      if (emitNothingOnEmptyBody) {
+        return "";
+      } else {
+        logger.debug("Emitting empty body {}", sb);
+      }
+    }
+    if (addSemicolonNewlineWhenBuild) {
+      sb.append(" ;\n");
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Given a list of elements, concat the quoted id's of those elements, separated by commas,
+   * and appends it to the given StringBuilder.
+   * @param listOfElements the list of elements to concat
+   */
+  private void concatIds(Iterable<? extends ModelElement> listOfElements) {
+    concatNodes(listOfElements, ModelElement::getID, true);
+  }
+
+  /**
+   * Given a list of elements, concat the quoted id's of those elements, separated by commas,
+   * and appends it to the given StringBuilder.
+   * @param listOfNodes the list of nodes
+   * @param mapping a function to map a node to a ModelElement
+   */
+  private <T extends ASTNode> void concatIds(Iterable<T> listOfNodes,
+                                             Function<T, ? extends ModelElement> mapping) {
+    concatNodes(listOfNodes, t -> mapping.apply(t).getID(), true);
+  }
+
+  /**
+   * Given a list of nodes, apply a function on each of those, concat the output (separated by commas),
+   * and appends it to the given StringBuilder.
+   * @param listOfNodes the list of nodes
+   * @param mapping a function to map a node to a String
+   */
+  private <T extends ASTNode> void concatNodes(Iterable<T> listOfNodes,
+                                               Function<T, String> mapping,
+                                               boolean quote) {
+    boolean first = true;
+    for (T t : listOfNodes) {
+      if (first) {
+        first = false;
+      } else {
+        sb.append(", ");
+      }
+      if (quote) {
+        sb.append("\"");
+      }
+      sb.append(mapping.apply(t));
+      if (quote) {
+        sb.append("\"");
+      }
+    }
+  }
+
+  /**
+   * Appends model elements to the builder, if their number is positive.
+   * @param name           The name of the member
+   * @param listOfElements The list of model elements
+   * @return this
+   */
+  public MemberPrinter addIds(String name, List<? extends ModelElement> listOfElements) {
+    return addIds(name, listOfElements.size(), listOfElements);
+  }
+
+  /**
+   * Appends model elements to the builder, if count is positive.
+   * @param name           The name of the member
+   * @param count          The number of items in the listOfElements
+   * @param listOfElements The list of model elements
+   * @return this
+   */
+  public MemberPrinter addIds(String name, int count, Iterable<? extends ModelElement> listOfElements) {
+    if (count > 0) {
+      sb.append(' ').append(name).append("=[");
+      concatIds(listOfElements);
+      sb.append("]");
+      this.empty = false;
+    }
+    return this;
+  }
+
+  /**
+   * Appends nodes to the builder, if count is positive.
+   * @param name        The name of the member
+   * @param count       The number of items in the listOfNodes
+   * @param listOfNodes The list of nodes
+   * @param mapping     A function to map a node to a ModelElement
+   * @return this
+   */
+  public <T extends ASTNode> MemberPrinter addIds(
+      String name, int count, Iterable<T> listOfNodes,
+      Function<T, ? extends ModelElement> mapping) {
+    if (count > 0) {
+      sb.append(' ').append(name).append("=[");
+      concatIds(listOfNodes, mapping);
+      sb.append("]");
+      this.empty = false;
+    }
+    return this;
+  }
+
+  /**
+   * Applies the mapping to each node and appends the results to the builder, if count is positive.
+   * The list is enclosed with square brackets.
+   * @param name        The name of the member
+   * @param count       The number of items in the listOfNodes
+   * @param listOfNodes The list of nodes
+   * @param mapping     A function to map a node to a String
+   * @param <T>         The type of all nodes
+   * @return this
+   */
+  public <T extends ASTNode> MemberPrinter addNodes(String name, int count, Iterable<T> listOfNodes,
+                                Function<T, String> mapping) {
+    return addNodes(name, count, listOfNodes, mapping, ListBracketType.SQUARE);
+  }
+
+  /**
+   * Applies the mapping to each node and appends the results to the builder, if count is positive
+   * @param name        The name of the member
+   * @param count       The number of items in the listOfNodes
+   * @param listOfNodes The list of nodes
+   * @param mapping     A function to map a node to a String
+   * @param <T>         The type of all nodes
+   * @param bracketType The type of brackets to enclose the list with
+   * @return this
+   */
+  public <T extends ASTNode> MemberPrinter addNodes(String name, int count, Iterable<T> listOfNodes,
+                                                    Function<T, String> mapping, ListBracketType bracketType) {
+    if (count > 0) {
+      sb.append(' ').append(name).append("=").append(bracketType.begin);
+      concatNodes(listOfNodes, mapping, false);
+      sb.append(bracketType.end);
+      this.empty = false;
+    }
+    return this;
+  }
+
+  /**
+   * Appends a value to the builder, if the value is present.
+   * A function is used to get the value, such that it is only evaluated if the value is present
+   * @param name        The name of the member
+   * @param isPresent   Whether the optional value is present
+   * @param valueGetter A function to get the value
+   * @return this
+   */
+  public MemberPrinter addOptional(String name, boolean isPresent, Supplier<String> valueGetter) {
+    if (isPresent) {
+      return add(name, valueGetter.get());
+    }
+    return this;
+  }
+
+  /**
+   * Appends the result of calling {@link ASTNode#prettyPrint()} for the child, if non-<code>null</code>.
+   * @param child       The child to append
+   * @return this
+   */
+  public MemberPrinter addOptionalPrettyPrint(ASTNode child) {
+    if (child != null) {
+      this.empty = false;
+      sb.append(child.prettyPrint());
+    }
+    return this;
+  }
+
+  /**
+   * Appends a the name of the flag, if it is set
+   * @param name        The name of the member
+   * @param isSet       Whether the flag is set
+   * @return this
+   */
+  public MemberPrinter addFlag(String name, boolean isSet) {
+    if (isSet) {
+      this.empty = false;
+      sb.append(' ').append(name);
+    }
+    return this;
+  }
+
+  /**
+   * Appends a value to the builder, if the value is not <code>null</code> and not empty
+   * @param name        The name of the member
+   * @param actualValue The value to append
+   * @return this
+   */
+  public MemberPrinter addNonDefault(String name, String actualValue) {
+    return addNonDefault(name, actualValue, "");
+  }
+
+  /**
+   * Appends a value to the builder, if the value is not the given default
+   * @param name         The name of the member
+   * @param actualValue  The value to append
+   * @param defaultValue The default value
+   * @return this
+   */
+  public MemberPrinter addNonDefault(String name, Object actualValue, Object defaultValue) {
+    if (!actualValue.equals(defaultValue)) {
+      this.empty = false;
+      return add(name, actualValue);
+    }
+    return this;
+  }
+
+  /**
+   * Appends a value to the builder, and issue a warning if it is either <code>null</code> or empty.
+   * @param name         The name of the member
+   * @param actualValue  The value to append
+   * @return this
+   */
+  public MemberPrinter addRequired(String name, Object actualValue) {
+    if (actualValue == null || actualValue.toString().isEmpty()) {
+      logger.warn("Member \"{}\" not defined while printing", name);
+      actualValue = "";
+    }
+    return add(name, actualValue);
+  }
+
+  /**
+   * Appends a value to the builder, and issue a warning if it is either <code>null</code> or empty.
+   * @param name         The name of the member
+   * @param objectValue  An object to append
+   * @param mapping      A function to get the real value from the object
+   * @return this
+   */
+  public <T> MemberPrinter addRequired(String name, T objectValue, Function<T, String> mapping) {
+    String actualValue;
+    if (objectValue == null) {
+      logger.warn("Member \"{}\" not defined while printing", name);
+      actualValue = "";
+    } else {
+      actualValue = mapping.apply(objectValue);
+      if (actualValue.isEmpty()) {
+        logger.warn("Member \"{}\" empty while printing", name);
+      }
+    }
+    return add(name, actualValue);
+  }
+
+  private MemberPrinter add(String name, Object actualValue) {
+    this.empty = false;
+    sb.append(' ').append(name).append("=\"").append(actualValue).append("\"");
+    return this;
+  }
+
+}

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/MqttReceiver.java

 package de.tudresden.inf.st.eraser.util;
 
-import de.tudresden.inf.st.eraser.openhab2.mqtt.MQTTUpdater;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.fusesource.hawtbuf.Buffer;
@@ -40,7 +39,7 @@ public class MqttReceiver implements AutoCloseable {
   private QoS qos;
 
   public MqttReceiver() {
-    this.logger = LogManager.getLogger(MQTTUpdater.class);
+    this.logger = LogManager.getLogger(MqttReceiver.class);
     this.readyLock = new ReentrantLock();
     this.readyCondition = readyLock.newCondition();
     this.ready = false;
@@ -50,8 +49,8 @@ public class MqttReceiver implements AutoCloseable {
   /**
    * Sets the host to receive messages from
    */
-  public void setHost(String host) {
-    this.host = URI.create("tcp://" + host + ":1883");
+  public void setHost(String host, int port) {
+    this.host = URI.create("tcp://" + host + ":" + port);
     logger.debug("Host is {}", this.host);
   }
 
@@ -134,6 +133,17 @@ public class MqttReceiver implements AutoCloseable {
     connection.connect(new Callback<Void>() {
       @Override
       public void onSuccess(Void value) {
+        connection.publish("components", "Eraser is listening".getBytes(), QoS.AT_LEAST_ONCE, false, new Callback<Void>() {
+          @Override
+          public void onSuccess(Void value) {
+            logger.debug("success sending welcome message");
+          }
+
+          @Override
+          public void onFailure(Throwable value) {
+            logger.debug("failure sending welcome message", value);
+          }
+        });
         Topic[] topicArray = Arrays.stream(topics).map(topicName -> new Topic(topicName, qos)).toArray(Topic[]::new);
         logger.info("Connected, subscribing to {} topic(s) now.", topicArray.length);
         connection.subscribe(topicArray, new Callback<byte[]>() {
@@ -151,7 +161,7 @@ public class MqttReceiver implements AutoCloseable {
 
           @Override
           public void onFailure(Throwable cause) {
-            logger.error("Could not subscribe, because {}", cause);
+            logger.error("Could not subscribe", cause);
           }
         });
       }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/ParserUtils.java

@@ -3,12 +3,10 @@ package de.tudresden.inf.st.eraser.util;
 import beaver.Parser;
 import beaver.Scanner;
 import beaver.Symbol;
-import de.tudresden.inf.st.eraser.jastadd.model.Group;
-import de.tudresden.inf.st.eraser.jastadd.model.Item;
-import de.tudresden.inf.st.eraser.jastadd.model.MqttTopic;
-import de.tudresden.inf.st.eraser.jastadd.model.Root;
+import de.tudresden.inf.st.eraser.jastadd.model.*;
 import de.tudresden.inf.st.eraser.jastadd.parser.EraserParser;
 import de.tudresden.inf.st.eraser.jastadd.scanner.EraserScanner;
+import de.tudresden.inf.st.eraser.parser.EraserParserHelper;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -16,8 +14,8 @@ import java.io.*;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import java.util.*;
-import java.util.stream.Collectors;
+import java.util.Collection;
+import java.util.Objects;
 
 /**
  * Utility methods involving scanner and parser of the models.
@@ -26,9 +24,42 @@ import java.util.stream.Collectors;
  */
 public class ParserUtils {
 
+  public static final String UNKNOWN_GROUP_NAME = "Unknown";
   private static boolean verboseLoading = false;
   private static final Logger logger = LogManager.getLogger(ParserUtils.class);
 
+  private interface ReaderProvider {
+    Reader provide() throws IOException;
+  }
+
+  private static class ReaderProviderByName implements ReaderProvider {
+    private final String filename;
+    private final Class<?> clazz;
+
+    ReaderProviderByName(String filename, Class<?> clazz) {
+      this.filename = filename;
+      this.clazz = clazz;
+    }
+
+    @Override
+    public Reader provide() throws IOException {
+      return getReader(filename, clazz);
+    }
+  }
+
+  private static class ReaderProviderByURL implements ReaderProvider {
+    private final URL url;
+
+    ReaderProviderByURL(URL url) {
+      this.url = url;
+    }
+
+    @Override
+    public Reader provide() throws IOException {
+      return new InputStreamReader(url.openStream());
+    }
+  }
+
   /**
    * Print read tokens before loading the model.
    * This will effectively parse the input two times, thus slowing the operation.
@@ -71,8 +102,23 @@ public class ParserUtils {
    */
   public static Root load(String fileName, Class<?> clazz) throws IOException, Parser.Exception {
     logger.info("Loading model DSL file '{}'", fileName);
+    return load(new ReaderProviderByName(fileName, clazz));
+  }
+
+  /**
+   * Loads a model in a file from the given URL.
+   * @param url an URL pointing to a file
+   * @return the parsed model
+   * @throws IOException if the file could not be found, or opened
+   * @throws Parser.Exception if the file contains a malformed model
+   */
+  public static Root load(URL url) throws IOException, Parser.Exception {
+    logger.info("Loading model DSL from '{}'", url);
+    return load(new ReaderProviderByURL(url));
+  }
 
-    Reader reader = getReader(fileName, clazz);
+  private static Root load(ReaderProvider readerProvider) throws IOException, Parser.Exception {
+    Reader reader = readerProvider.provide();
     if (verboseLoading) {
       EraserScanner scanner = new EraserScanner(reader);
       try {
@@ -87,7 +133,7 @@ public class ParserUtils {
         try {
           reader.reset();
         } catch (IOException resetEx) {
-          reader = getReader(fileName, clazz);
+          reader = readerProvider.provide();
         }
       }
     }
@@ -120,63 +166,91 @@ public class ParserUtils {
     }
   }
 
-  public static void createUnknownGroup(Root model, Collection<Item> danglingItems) {
+  /**
+   * Create well-known group call "Unknown" and add all dangling items to it.
+   * @param model         The model to operate on
+   * @param danglingItems A list of items to add to the new group
+   */
+  public static void createUnknownGroup(OpenHAB2Model model, Collection<Item> danglingItems) {
     Group unknownGroup = new Group();
-    unknownGroup.setID("Unknown");
+    unknownGroup.setID(UNKNOWN_GROUP_NAME);
     model.addGroup(unknownGroup);
     danglingItems.forEach(unknownGroup::addItem);
-    logger.warn("Creating group 'Unknown' for items: {}", PrinterUtils.concatIds(danglingItems));
+    logger.info("Created new {}", unknownGroup.prettyPrint().trim());
   }
 
-  public static void createMqttTopic(Item item, String topicName, Root root) {
-    String[] parts = topicName.split("/");
-    String firstPart = parts[0];
-    MqttTopic firstTopic = null;
-    for (MqttTopic topic : root.getMqttRoot().getTopicList()) {
-      if (topic.getPart().equals(firstPart)) {
-        firstTopic = topic;
-        break;
+  /**
+   * Create a topic for the given topic name and assign it to the given item.
+   * @param item        The item to which the topic will be assigned to
+   * @param topicSuffix The full topic name
+   * @param root        The model to operate on
+   */
+  public static void createMqttTopic(Item item, String topicSuffix, Root root) {
+    item.setTopic(root.getMqttRoot().resolveTopicSuffix(topicSuffix).orElseGet(() -> {
+      MqttTopic result = new MqttTopic();
+      result.setTopicString(topicSuffix);
+      root.getMqttRoot().addTopic(result);
+      return result;
+    }));
   }
+
+  public static NumberExpression parseNumberExpression(String expression_string) throws IOException, Parser.Exception {
+    return parseNumberExpression(expression_string, null);
   }
-    if (firstTopic == null) {
-      // no matching topic found for first part. create one.
-      firstTopic = createTopic(firstPart, root);
+
+  public static LogicalExpression parseLogicalExpression(String expression_string) throws IOException, Parser.Exception {
+    return parseLogicalExpression(expression_string, null);
   }
-//    MqttTopic firstTopic = firstPartTopicMap.computeIfAbsent(firstPart, part -> createTopic(part, root));
-    MqttTopic lastTopic = processRemainingTopicParts(firstTopic, parts, 1);
-    item.setTopic(lastTopic);
+
+  public static NumberExpression parseNumberExpression(String expression_string, Root root) throws IOException, Parser.Exception {
+    return (NumberExpression) parseExpression(expression_string, EraserParser.AltGoals.number_expression, root);
   }
 
-  private static MqttTopic processRemainingTopicParts(MqttTopic topic, String[] parts, int index) {
-    if (index >= parts.length) {
-      return topic;
+  public static LogicalExpression parseLogicalExpression(String expression_string, Root root) throws IOException, Parser.Exception {
+    return (LogicalExpression) parseExpression(expression_string, EraserParser.AltGoals.logical_expression, root);
   }
-    for (MqttTopic subTopic : topic.getSubTopicList()) {
-      if (subTopic.getPart().equals(parts[index])) {
-        // matching part found
-        return processRemainingTopicParts(subTopic, parts, index + 1);
+
+  private static Expression parseExpression(String expression_string, short alt_goal, Root root) throws IOException, Parser.Exception {
+    EraserParserHelper.setInitialRoot(root);
+    StringReader reader = new StringReader(expression_string);
+    if (verboseLoading) {
+      EraserScanner scanner = new EraserScanner(reader);
+      try {
+        Symbol token;
+        while ((token = scanner.nextToken()).getId() != EraserParser.Terminals.EOF) {
+          logger.debug("start: {}, end: {}, id: {}, value: {}",
+              token.getStart(), token.getEnd(), EraserParser.Terminals.NAMES[token.getId()], token.value);
         }
+      } catch (Scanner.Exception e) {
+        e.printStackTrace();
       }
-    // no matching part was found. create remaining topics.
-    for (int currentIndex = index; currentIndex < parts.length; currentIndex++) {
-      MqttTopic newTopic = createSubTopic(parts[currentIndex]);
-      topic.addSubTopic(newTopic);
-      topic = newTopic;
     }
-    return topic;
+    reader = new StringReader(expression_string);
+    EraserScanner scanner = new EraserScanner(reader);
+    EraserParser parser = new EraserParser();
+    Expression result = (Expression) parser.parse(scanner, alt_goal);
+    parser.resolveReferences();
+    reader.close();
+    EraserParserHelper.setInitialRoot(null);
+    return result;
   }
 
-  private static MqttTopic createSubTopic(String part) {
-    return createTopic(part, null);
+  public static Item parseItem(String definition)
+      throws IllegalArgumentException, IOException, Parser.Exception {
+    StringReader reader = new StringReader(definition);
+    EraserScanner scanner = new EraserScanner(reader);
+    EraserParser parser = new EraserParser();
+    Root root = (Root) parser.parse(scanner);
+    parser.resolveReferences();
+    reader.close();
+    int size = root.getOpenHAB2Model().items().size();
+    if (size == 0) {
+      throw new IllegalArgumentException("Model does not contain any items!");
     }
-
-  private static MqttTopic createTopic(String part, Root root) {
-    MqttTopic result = new MqttTopic();
-    result.setPart(part);
-    if (root != null) {
-      root.getMqttRoot().addTopic(result);
+    if (size > 1) {
+      logger.warn("Model does contain {} items, ignoring all but the first.", size);
     }
-    return result;
+    return root.getOpenHAB2Model().items().get(0);
   }
 
 }

eraser-base/src/main/java/de/tudresden/inf/st/eraser/util/PrinterUtils.java

-package de.tudresden.inf.st.eraser.util;
-
-import de.tudresden.inf.st.eraser.jastadd.model.ASTNode;
-import de.tudresden.inf.st.eraser.jastadd.model.JastAddList;
-import de.tudresden.inf.st.eraser.jastadd.model.ModelElement;
-
-import java.util.function.Function;
-
-/**
- * Helper methods shared by multiple non-terminals.
- *
- * @author rschoene - Initial contribution
- */
-public class PrinterUtils {
-
-  /**
-   * Given a list of elements, concat the quoted id's of those elements, separated by commas.
-   * @param listOfElements the list of elements to concat
-   * @return a comma-separated list of the ids of the given elements
-   */
-  public static String concatIds(Iterable<? extends ModelElement> listOfElements) {
-    return concatIds(new StringBuilder(), listOfElements).toString();
-  }
-
-  /**
-   * Given a list of elements, concat the quoted id's of those elements, separated by commas,
-   * and appends it to the given StringBuilder.
-   * @param sb the StringBuilder to append to
-   * @param listOfElements the list of elements to concat
-   * @return the given StringBuilder
-   */
-  public static StringBuilder concatIds(StringBuilder sb, Iterable<? extends ModelElement> listOfElements) {
-    boolean first = true;
-    for (ModelElement c : listOfElements) {
-      if (first) {
-        first = false;
-      } else {
-        sb.append(", ");
-      }
-      sb.append("\"").append(c.getID()).append("\"");
-    }
-    return sb;
-  }
-
-  /**
-   * Given a list of elements, concat the quoted id's of those elements, separated by commas,
-   * and appends it to the given StringBuilder.
-   * @param sb the StringBuilder to append to
-   * @param listOfNodes the list of nodes
-   * @param mapping a function to map a node to a ModelElement
-   * @return the given StringBuilder
-   */
-  public static <T extends ASTNode> StringBuilder concatIds(StringBuilder sb, Iterable<T> listOfNodes,
-                                                            Function<T, ? extends ModelElement> mapping) {
-    boolean first = true;
-    for (T t : listOfNodes) {
-      if (first) {
-        first = false;
-      } else {
-        sb.append(", ");
-      }
-      sb.append("\"").append(mapping.apply(t).getID()).append("\"");
-    }
-    return sb;
-  }
-
-}

eraser-base/src/main/resources/log4j2.xml

@@ -4,8 +4,8 @@
         <Console name="Console">
             <PatternLayout pattern="%highlight{%d{HH:mm:ss.SSS} %-5level} %c{1.} - %msg%n"/>
         </Console>
-        <RollingFile name="RollingFile" fileName="logs/jastadd-mquat.log"
-                    filePattern="logs/jastadd-mquat-%i.log">
+        <RollingFile name="RollingFile" fileName="logs/eraser.log"
+                    filePattern="logs/eraser-%i.log">
             <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} - %msg%n"/>
             <Policies>
                 <OnStartupTriggeringPolicy/>