Rename ItemPreference to ItemUpdate.

- Update to latest relast version 0.2.2

eraser-base/src/main/jastadd/DecisionTree.jrag

@@ -52,15 +52,15 @@ aspect DecisionTree {
     MachineLearningResult result = new MachineLearningResult();
     Set<Item> seenItems = new HashSet<>();
     List<DecisionTreeElement> ancestors = ancestors();
-    for (ItemPreference pref : getPreferenceList()) {
-      result.addItemPreference(pref);
-      seenItems.add(pref.getItem());
+    for (ItemUpdate update : getPreferenceList()) {
+      result.addItemUpdate(update);
+      seenItems.add(update.getItem());
     }
     for (DecisionTreeElement ancestor : ancestors) {
-      for (ItemPreference pref : ancestor.getPreferenceList()) {
-        if (!seenItems.contains(pref.getItem())) {
-          result.addItemPreference(pref);
-          seenItems.add(pref.getItem());
+      for (ItemUpdate update : ancestor.getPreferenceList()) {
+        if (!seenItems.contains(update.getItem())) {
+          result.addItemUpdate(update);
+          seenItems.add(update.getItem());
         }
       }
     }

eraser-base/src/main/jastadd/DecisionTree.relast

 // ----------------    Decision Tree    ------------------------------
 DecisionTreeRoot : InternalMachineLearningModel ::= RootRule:DecisionTreeRule ;
-abstract DecisionTreeElement ::= Preference:ItemPreference*;
+abstract DecisionTreeElement ::= Preference:ItemUpdate*;
 abstract DecisionTreeRule : DecisionTreeElement ::= Left:DecisionTreeElement Right:DecisionTreeElement <Label:String> ;
 ItemStateCheckRule : DecisionTreeRule ::= ItemStateCheck ;
 

eraser-base/src/main/jastadd/Item.jrag

@@ -398,33 +398,33 @@ aspect ItemHandling {
     setState(getState().withDifferentBrightness(value));
   }
 
-  //--- ItemPreference.apply ---
-  public abstract void ItemPreference.apply();
-  public void ItemPreferenceColor.apply() {
-    getItem().setStateFromColor(getPreferredHSB());
+  //--- ItemUpdate.apply ---
+  public abstract void ItemUpdate.apply();
+  public void ItemUpdateColor.apply() {
+    getItem().setStateFromColor(getNewHSB());
     getItem().freeze();
     for (Item controller : getItem().getControlledByList()) {
-      controller.setStateFromColor(getPreferredHSB());
+      controller.setStateFromColor(getNewHSB());
     }
     getItem().unfreeze();
   }
-  //--- ItemPreference.apply ---
-  public void ItemPreferenceDouble.apply() {
-    getItem().setStateFromDouble(getPreferredValue());
+  //--- ItemUpdate.apply ---
+  public void ItemUpdateDouble.apply() {
+    getItem().setStateFromDouble(getNewValue());
     getItem().freeze();
     for (Item controller : getItem().getControlledByList()) {
-      controller.setStateFromDouble(getPreferredValue());
+      controller.setStateFromDouble(getNewValue());
     }
     getItem().unfreeze();
   }
 
-  //--- ItemPreference.describe ---
-  syn String ItemPreference.describe() = getItem().getID() + " -> " + getNewStateAsString();
+  //--- ItemUpdate.describe ---
+  syn String ItemUpdate.describe() = getItem().getID() + " -> " + getNewStateAsString();
 
-  //--- ItemPreference.getNewStateAsString ---
-  syn String ItemPreference.getNewStateAsString();
-  eq ItemPreferenceColor.getNewStateAsString() = getPreferredHSB().toString();
-  eq ItemPreferenceDouble.getNewStateAsString() = Double.toString(getPreferredValue());
+  //--- ItemUpdate.getNewStateAsString ---
+  syn String ItemUpdate.getNewStateAsString();
+  eq ItemUpdateColor.getNewStateAsString() = getNewHSB().toString();
+  eq ItemUpdateDouble.getNewStateAsString() = Double.toString(getNewValue());
 
 //  // override Item.init$Children from JastAdd's own ASTNode aspect
 //  refine ASTNode public void Item.init$Children() {

eraser-base/src/main/jastadd/Logging.jadd

 aspect Logging {
   // Base
   protected org.apache.logging.log4j.Logger Item.logger = org.apache.logging.log4j.LogManager.getLogger(Item.class);
-  protected org.apache.logging.log4j.Logger ItemPreference.logger = org.apache.logging.log4j.LogManager.getLogger(ItemPreference.class);
+  protected org.apache.logging.log4j.Logger ItemUpdate.logger = org.apache.logging.log4j.LogManager.getLogger(ItemUpdate.class);
 
   // MachineLearning
   private org.apache.logging.log4j.Logger DummyMachineLearningModel.logger = org.apache.logging.log4j.LogManager.getLogger(DummyMachineLearningModel.class);

eraser-base/src/main/jastadd/MachineLearning.jrag

@@ -24,15 +24,15 @@ aspect MachineLearning {
   syn java.util.Optional<Activity> Root.currentActivity() {
     return resolveActivity((int) getSmartHomeEntityModel().getActivityItem().getState());
   }
-  private int Root.extractActivityIdentifier(List<ItemPreference> preferences) {
-    if (preferences.isEmpty()) {
+  private int Root.extractActivityIdentifier(List<ItemUpdate> updates) {
+    if (updates.isEmpty()) {
       return -1;
     }
-    return (int) ((ItemPreferenceDouble) preferences.get(0)).getPreferredValue();
+    return (int) ((ItemUpdateDouble) updates.get(0)).getNewValue();
   }
 
 //  //--- currentPreferences ---
-//  syn List<ItemPreference> Root.currentPreferences() = getMachineLearningRoot().getPreferenceLearning().getDecoder().classify().getItemPreferences();
+//  syn List<ItemUpdate> Root.currentPreferences() = getMachineLearningRoot().getPreferenceLearning().getDecoder().classify().getItemUpdates();
 
   //--- canSetActivity ---
   syn boolean MachineLearningModel.canSetActivity() = false;
@@ -170,7 +170,7 @@ aspect MachineLearning {
   //--- classify ---
   public MachineLearningResult MachineLearningModel.classify() {
     MachineLearningResult result = getDecoder().classify();
-    setLastPreference(result);
+    setLastResult(result);
     return result;
   }
 
@@ -180,29 +180,29 @@ aspect MachineLearning {
       return false;
     }
     MachineLearningResult otherResult = (MachineLearningResult) other;
-    if (getNumItemPreference() != otherResult.getNumItemPreference()) {
+    if (getNumItemUpdate() != otherResult.getNumItemUpdate()) {
       return false;
     }
-    for (int i = 0; i < getNumItemPreference(); i++) {
-      if (!getItemPreference(i).equals(otherResult.getItemPreference(i))) {
+    for (int i = 0; i < getNumItemUpdate(); i++) {
+      if (!getItemUpdate(i).equals(otherResult.getItemUpdate(i))) {
         return false;
       }
     }
     return true;
   }
 
-  public abstract boolean ItemPreference.equals(Object other);
-  public boolean ItemPreferenceDouble.equals(Object other) {
-    if (!(other instanceof ItemPreferenceDouble)) {
+  public abstract boolean ItemUpdate.equals(Object other);
+  public boolean ItemUpdateDouble.equals(Object other) {
+    if (!(other instanceof ItemUpdateDouble)) {
       return false;
     }
-    return getItem() == ((ItemPreferenceDouble) other).getItem() && getPreferredValue() == ((ItemPreferenceDouble) other).getPreferredValue();
+    return getItem() == ((ItemUpdateDouble) other).getItem() && getNewValue() == ((ItemUpdateDouble) other).getNewValue();
   }
-  public boolean ItemPreferenceColor.equals(Object other) {
-    if (!(other instanceof ItemPreferenceColor)) {
+  public boolean ItemUpdateColor.equals(Object other) {
+    if (!(other instanceof ItemUpdateColor)) {
       return false;
     }
-    return getItem() == ((ItemPreferenceColor) other).getItem() && getPreferredHSB() == ((ItemPreferenceColor) other).getPreferredHSB();
+    return getItem() == ((ItemUpdateColor) other).getItem() && getNewHSB() == ((ItemUpdateColor) other).getNewHSB();
   }
 }
 
@@ -216,8 +216,8 @@ aspect ChangeEvents {
     for (Item relevantItem : modelOfRecognition.getRelevantItems()) {
       result.addRelevantItem(ChangedItem.newFrom(relevantItem));
     }
-    if (modelOfRecognition.hasLastPreference()) {
-      for (ItemPreference preference : modelOfRecognition.getLastPreference().getItemPreferences()) {
+    if (modelOfRecognition.hasLastResult()) {
+      for (ItemUpdate preference : modelOfRecognition.getLastResult().getItemUpdates()) {
         result.addChangedItem(ChangedItem.newFrom(preference));
       }
     }
@@ -232,8 +232,8 @@ aspect ChangeEvents {
     return result;
   }
 
-  //--- newFrom ItemPreference ---
-  public static ChangedItem ChangedItem.newFrom(ItemPreference update) {
+  //--- newFrom ItemUpdate ---
+  public static ChangedItem ChangedItem.newFrom(ItemUpdate update) {
     ChangedItem result = new ChangedItem();
     result.setItem(update.getItem());
     result.setNewStateAsString(update.getNewStateAsString());

eraser-base/src/main/jastadd/MachineLearning.relast

@@ -14,7 +14,7 @@ rel RecognitionEvent.RelevantItem* -> ChangedItem ;
 
 ManualChangeEvent : ChangeEvent ;
 
-abstract MachineLearningModel ::= [LastPreference:MachineLearningResult] ;
+abstract MachineLearningModel ::= [LastResult:MachineLearningResult] ;
 rel MachineLearningModel.RelevantItem* <-> Item.RelevantInMachineLearningModel* ;
 rel MachineLearningModel.TargetItem* <-> Item.TargetInMachineLearningModel* ;
 
@@ -22,10 +22,10 @@ ExternalMachineLearningModel : MachineLearningModel ;
 
 abstract InternalMachineLearningModel : MachineLearningModel ::= <OutputApplication:DoubleDoubleFunction> ;
 
-MachineLearningResult ::= ItemPreference* ;
+MachineLearningResult ::= ItemUpdate* ;
 
-abstract ItemPreference ::= ;
-rel ItemPreference.Item -> Item ;
+abstract ItemUpdate ::= ;
+rel ItemUpdate.Item -> Item ;
 
-ItemPreferenceColor : ItemPreference ::= <PreferredHSB:TupleHSB> ;
-ItemPreferenceDouble : ItemPreference ::= <PreferredValue:double> ;
+ItemUpdateColor : ItemUpdate ::= <NewHSB:TupleHSB> ;
+ItemUpdateDouble : ItemUpdate ::= <NewValue:double> ;

eraser-base/src/main/jastadd/NeuralNetwork.jrag

@@ -20,7 +20,7 @@ aspect NeuralNetwork {
     }
     public MachineLearningResult computePreferences() {
       MachineLearningResult result = new MachineLearningResult();
-      result.addItemPreference(new ItemPreferenceDouble(affectedItem, number));
+      result.addItemUpdate(new ItemUpdateDouble(affectedItem, number));
       return result;
     }
   }

eraser-base/src/test/java/de/tudresden/inf/st/eraser/DecisionTreeTest.java

@@ -145,23 +145,23 @@ public class DecisionTreeTest {
   }
 
   private ItemStateCheckRule newRule(DecisionTreeElement left, DecisionTreeElement right, String label,
-                                     ItemStateNumberCheck check, ItemPreference... preferences) {
+                                     ItemStateNumberCheck check, ItemUpdate... updates) {
     ItemStateCheckRule result = new ItemStateCheckRule();
     result.setLeft(left);
     result.setRight(right);
     result.setLabel(label);
     result.setItemStateCheck(check);
-    for (ItemPreference preference : preferences) {
-      result.addPreference(preference);
+    for (ItemUpdate update : updates) {
+      result.addPreference(update);
     }
     return result;
   }
 
-  private DecisionTreeLeaf newLeaf(String label, ItemPreference... preferences) {
+  private DecisionTreeLeaf newLeaf(String label, ItemUpdate... updates) {
     DecisionTreeLeaf result = new DecisionTreeLeaf();
     result.setLabel(label);
-    for (ItemPreference preference : preferences) {
-      result.addPreference(preference);
+    for (ItemUpdate update : updates) {
+      result.addPreference(update);
     }
     return result;
   }

feedbackloop.analyze/src/main/java/de/tudresden/inf/st/eraser/feedbackloop/analyze/AnalyzeImpl.java

@@ -3,7 +3,7 @@ package de.tudresden.inf.st.eraser.feedbackloop.analyze;
 import de.tudresden.inf.st.eraser.feedbackloop.api.Analyze;
 import de.tudresden.inf.st.eraser.feedbackloop.api.Plan;
 import de.tudresden.inf.st.eraser.jastadd.model.Activity;
-import de.tudresden.inf.st.eraser.jastadd.model.ItemPreference;
+import de.tudresden.inf.st.eraser.jastadd.model.ItemUpdate;
 import de.tudresden.inf.st.eraser.jastadd.model.MachineLearningResult;
 import de.tudresden.inf.st.eraser.jastadd.model.Root;
 import org.apache.logging.log4j.LogManager;
@@ -45,7 +45,7 @@ public class AnalyzeImpl implements Analyze {
   @Override
   public void analyzeLatestChanges() {
     MachineLearningResult recognitionResult = knowledgeBase.getMachineLearningRoot().getActivityRecognition().getDecoder().classify();
-    recognitionResult.getItemPreferences().forEach(ItemPreference::apply);
+    recognitionResult.getItemUpdates().forEach(ItemUpdate::apply);
     knowledgeBase.currentActivity().ifPresent(activity -> {
       MachineLearningResult newMLResult = knowledgeBase.getMachineLearningRoot().getPreferenceLearning().classify();
       // check if activity has changed

feedbackloop.api/src/main/java/de/tudresden/inf/st/eraser/feedbackloop/api/Execute.java

 package de.tudresden.inf.st.eraser.feedbackloop.api;
 
 import de.tudresden.inf.st.eraser.commons.color.ColorUtils.RGBvalues;
-import de.tudresden.inf.st.eraser.jastadd.model.ItemPreference;
+import de.tudresden.inf.st.eraser.jastadd.model.ItemUpdate;
 import de.tudresden.inf.st.eraser.jastadd.model.Root;
 import de.tudresden.inf.st.eraser.util.Tuple;
 
-import java.util.List;
 import java.util.Map;
 
 /**
@@ -29,8 +28,8 @@ public interface Execute {
   void updateItems(Map<String, Tuple<Integer, RGBvalues>> brightnessAndRgbForItems);
 
   /**
-   * Updates items according to given preferences
-   * @param preferences tuples containing item and its new HSB value
+   * Updates items according to given updates
+   * @param updates tuples containing item and its new HSB value
    */
-  void updateItems(Iterable<ItemPreference> preferences);
+  void updateItems(Iterable<ItemUpdate> updates);
 }

feedbackloop.api/src/main/java/de/tudresden/inf/st/eraser/feedbackloop/api/Plan.java

 package de.tudresden.inf.st.eraser.feedbackloop.api;
 
 import de.tudresden.inf.st.eraser.jastadd.model.Activity;
-import de.tudresden.inf.st.eraser.jastadd.model.ItemPreference;
+import de.tudresden.inf.st.eraser.jastadd.model.ItemUpdate;
 import de.tudresden.inf.st.eraser.jastadd.model.Root;
 
-import java.util.List;
-
 /**
  * Third phase in the MAPE feedback loop, planning reconfiguration actions to adapt to recent changes.
  *
@@ -21,7 +19,7 @@ public interface Plan {
 
   void planToMatchPreferences(Activity activity);
 
-  default void informExecute(Iterable<ItemPreference> preferences) {
-    getExecute().updateItems(preferences);
+  default void informExecute(Iterable<ItemUpdate> updates) {
+    getExecute().updateItems(updates);
   }
 }

feedbackloop.execute/src/main/java/de/tudresden/inf/st/eraser/feedbackloop/execute/ExecuteImpl.java

@@ -29,7 +29,7 @@ public class ExecuteImpl implements Execute {
 
   @Override
   public void updateItems(Map<String, Tuple<Integer, RGBvalues>> brightnessAndRgbForItems) {
-    List<ItemPreference> preferences = new ArrayList<>();
+    List<ItemUpdate> updates = new ArrayList<>();
     for (Map.Entry<String, Tuple<Integer, RGBvalues>> entry : brightnessAndRgbForItems.entrySet()) {
       String itemId = entry.getKey();
       resolveOrLogError(itemId, item -> {
@@ -47,15 +47,15 @@ public class ExecuteImpl implements Execute {
           hsb = HSBvalues255.of(0, 100, brightness);
         }
         hsb.ensureBounds();
-        preferences.add(new ItemPreferenceColor(item, TupleHSB.of(hsb.hue, hsb.saturation, hsb.brightness)));
+        updates.add(new ItemUpdateColor(item, TupleHSB.of(hsb.hue, hsb.saturation, hsb.brightness)));
       });
     }
-    updateItems(preferences);
+    updateItems(updates);
   }
 
   @Override
-  public void updateItems(Iterable<ItemPreference> preferences) {
-    for (ItemPreference preference : preferences) {
+  public void updateItems(Iterable<ItemUpdate> updates) {
+    for (ItemUpdate preference : updates) {
       preference.apply();
     }
   }

feedbackloop.execute/src/test/java/de/tudresden/inf/st/eraser/feedbackloop/execute/ExecuteImplTest.java

@@ -38,7 +38,7 @@ public class ExecuteImplTest {
     Assert.assertEquals(0, numberItem.getState(), DELTA);
     Assert.assertEquals(TupleHSB.of(0, 0, 0), lamp.getState());
 
-    ItemPreference preference = new ItemPreferenceColor(lamp, TupleHSB.of(1, 2, 3));
+    ItemUpdate preference = new ItemUpdateColor(lamp, TupleHSB.of(1, 2, 3));
     execute.updateItems(Collections.singletonList(preference));
 
     Assert.assertEquals(3, numberItem.getState(), DELTA);
@@ -69,7 +69,7 @@ public class ExecuteImplTest {
     Assert.assertFalse(button.getState());
     Assert.assertEquals(TupleHSB.of(0, 0, 0), lamp.getState());
 
-    ItemPreference preference = new ItemPreferenceColor(lamp, TupleHSB.of(1, 2, 3));
+    ItemUpdate preference = new ItemUpdateColor(lamp, TupleHSB.of(1, 2, 3));
     execute.updateItems(Collections.singletonList(preference));
 
     Assert.assertTrue(button.getState());
@@ -116,7 +116,7 @@ public class ExecuteImplTest {
     Assert.assertEquals(TupleHSB.of(0, 0, 0), colorItem.getState());
     Assert.assertEquals(TupleHSB.of(0, 0, 0), lamp.getState());
 
-    ItemPreference preference = new ItemPreferenceColor(lamp, TupleHSB.of(1, 2, 3));
+    ItemUpdate preference = new ItemUpdateColor(lamp, TupleHSB.of(1, 2, 3));
     execute.updateItems(Collections.singletonList(preference));
 
     Assert.assertEquals(3, numberItem.getState(), DELTA);

feedbackloop.learner_backup/src/main/java/de/tudresden/inf/st/eraser/feedbackloop.learner_backup/MachineLearningImpl.java

@@ -161,14 +161,14 @@ public class MachineLearningImpl implements MachineLearningDecoder, MachineLearn
           return result;
         }
         Item activityItem = resolve(this.root.getSmartHomeEntityModel(), "activity");
-        ItemPreference classifiedActivity = null;
+        ItemUpdate classifiedActivity = null;
         for (Activity activity : this.root.getMachineLearningRoot().getActivityList()) {
           if (activity.getLabel().equals(activityStringValue)) {
-            classifiedActivity = new ItemPreferenceDouble(activityItem, activity.getIdentifier());
+            classifiedActivity = new ItemUpdateDouble(activityItem, activity.getIdentifier());
           }
         }
         if (classifiedActivity != null) {
-          result.addItemPreference(classifiedActivity);
+          result.addItemUpdate(classifiedActivity);
         }
         return result;
       case GOAL_PREFERENCE_BRIGHTNESS_IRIS:
@@ -179,7 +179,7 @@ public class MachineLearningImpl implements MachineLearningDecoder, MachineLearn
           color = Math.round(Float.valueOf(preference_result[0]));
           brightness = Math.round(Float.valueOf(preference_result[1]));
         }
-        result.addItemPreference(new ItemPreferenceColor(iris1, TupleHSB.of(color, 100, brightness)));
+        result.addItemUpdate(new ItemUpdateColor(iris1, TupleHSB.of(color, 100, brightness)));
         return result;
       default:
         logger.error("Unknown goal value ({}) set in classify", this.goal);

feedbackloop.plan/src/main/java/de/tudresden/inf/st/eraser/feedbackloop/plan/PlanImpl.java

@@ -6,8 +6,6 @@ import de.tudresden.inf.st.eraser.jastadd.model.*;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import java.util.List;
-
 /**
  * Reference implementation for Plan.
  *
@@ -37,17 +35,17 @@ public class PlanImpl implements Plan {
   @Override
   public void planToMatchPreferences(Activity activity) {
     logger.info("Plan got new activity [{}]: {}", activity.getIdentifier(), activity.getLabel());
-    MachineLearningResult mlResult = knowledgeBase.getMachineLearningRoot().getPreferenceLearning().getLastPreference();
-    knowledgeBase.getMachineLearningRoot().addChangeEvent(createRecognitionEvent(activity, mlResult.getItemPreferences()));
+    MachineLearningResult mlResult = knowledgeBase.getMachineLearningRoot().getPreferenceLearning().getLastResult();
+    knowledgeBase.getMachineLearningRoot().addChangeEvent(createRecognitionEvent(activity, mlResult.getItemUpdates()));
     knowledgeBase.getMachineLearningRoot().getChangeEventList();
-    informExecute(mlResult.getItemPreferences());
+    informExecute(mlResult.getItemUpdates());
   }
 
-  private ChangeEvent createRecognitionEvent(Activity activity, Iterable<ItemPreference> preferences) {
+  private ChangeEvent createRecognitionEvent(Activity activity, Iterable<ItemUpdate> updates) {
     RecognitionEvent result = RecognitionEvent.createRecognitionEvent(knowledgeBase.getMachineLearningRoot().getActivityRecognition());
     result.setActivity(activity);
-    for (ItemPreference preference : preferences) {
-      result.addChangedItem(ChangedItem.newFrom(preference));
+    for (ItemUpdate update : updates) {
+      result.addChangedItem(ChangedItem.newFrom(update));
     }
     return result;
   }