Update C++, mock improvements

Author: PeterJohnson

romiVendordep/src/main/native/cpp/romi/RomiMotor.cpp

@@ -6,7 +6,7 @@
 
 using namespace frc;
 
-RomiMotor::RomiMotor(int channel) : PWMMotorController("Romi Motor", channel) {
+RomiMotor::RomiMotor(int channel) : PWMMotorController(channel) {
   m_pwm.SetPeriodMultiplier(PWM::kPeriodMultiplier_1X);
   m_pwm.SetSpeed(0.0);
   m_pwm.SetZeroLatch();

telemetry/src/main/java/edu/wpi/first/telemetry/MockTelemetryBackend.java

@@ -11,33 +11,45 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.BiConsumer;
 
-/** A telemetry backend that saves logged data to an array for unit testing purposes. */
+/**
+ * A telemetry backend that saves logged data to an array for unit testing
+ * purposes.
+ */
 public class MockTelemetryBackend implements TelemetryBackend {
   /** Value for keepDuplicate() action. */
-  public record KeepDuplicateValue(boolean value) {}
+  public record KeepDuplicateValue(boolean value) {
+  }
 
   /** Value for setProperty() action. */
-  public record SetPropertyValue(String key, String value) {}
+  public record SetPropertyValue(String key, String value) {
+  }
 
   /** Value for logStruct() action. */
-  public record LogStructValue<T>(T value, Struct<T> struct) {}
+  public record LogStructValue<T>(T value, Struct<T> struct) {
+  }
 
   /** Value for logProtobuf() action. */
-  public record LogProtobufValue<T>(T value, Protobuf<T, ?> protobuf) {}
+  public record LogProtobufValue<T>(T value, Protobuf<T, ?> protobuf) {
+  }
 
   /** Value for logStructArray() action. */
-  public record LogStructArrayValue<T>(T[] value, Struct<T> struct) {}
+  public record LogStructArrayValue<T>(T[] value, Struct<T> struct) {
+  }
 
   /** Value for logString() action. */
-  public record LogStringValue(String value, String typeString) {}
+  public record LogStringValue(String value, String typeString) {
+  }
 
   /** Value for logRaw() action. */
-  public record LogRawValue(byte[] value, String typeString) {}
+  public record LogRawValue(byte[] value, String typeString) {
+  }
 
   /** A logged action. */
-  public record Action(String path, Object value) {}
+  public record Action(String path, Object value) {
+  }
 
   private final Map<String, Entry> m_entries = new HashMap<>();
   private final List<Action> m_actions = new ArrayList<>();
@@ -53,29 +65,68 @@ public List<Action> getActions() {
 
   /** Clear logged actions. */
   public void clear() {
-    m_actions.clear();
+    synchronized (this) {
+      for (Entry entry : m_entries.values()) {
+        entry.m_last = -1;
+      }
+      m_actions.clear();
+    }
+  }
+
+  /**
+   * Get the last action for a particular path.
+   *
+   * @param path path
+   * @return Action, or null if no update to that path
+   */
+  public Action getLastAction(String path) {
+    synchronized (this) {
+      Entry entry = m_entries.get(path);
+      if (entry == null || entry.m_last == -1) {
+        return null;
+      }
+      return m_actions.get(entry.m_last);
+    }
+  }
+
+  /**
+   * Get the last action value for a particular path.
+   *
+   * @param path path
+   * @return Value, or null if no update to that path
+   */
+  public <T> T getLastValue(String path, Class<T> cls) {
+    Action action = getLastAction(path);
+    if (action == null || !action.value.getClass().equals(cls)) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    T result = (T) action.value;
+    return result;
   }
 
   @Override
   public void close() {
-    synchronized (m_entries) {
+    synchronized (this) {
       m_entries.clear();
     }
   }
 
   @Override
   public TelemetryEntry getEntry(String path) {
-    synchronized (m_entries) {
+    synchronized (this) {
       return m_entries.computeIfAbsent(path, k -> new Entry(k));
     }
   }
 
   @Override
-  public void setReportWarning(BiConsumer<String, StackTraceElement[]> func) {}
+  public void setReportWarning(BiConsumer<String, StackTraceElement[]> func) {
+  }
 
-  private void log(String path, Object value) {
-    synchronized (m_actions) {
-      m_actions.add(new Action(path, value));
+  private void log(Entry entry, Object value) {
+    synchronized (this) {
+      entry.m_last = m_actions.size();
+      m_actions.add(new Action(entry.m_path, value));
     }
   }
 
@@ -86,19 +137,19 @@ private final class Entry implements TelemetryEntry {
 
     @Override
     public void keepDuplicates() {
-      log(m_path, new KeepDuplicateValue(true));
+      log(this, new KeepDuplicateValue(true));
     }
 
     @Override
     public void setProperty(String key, String value) {
-      log(m_path, new SetPropertyValue(key, value));
+      log(this, new SetPropertyValue(key, value));
     }
 
     @Override
     public <T> void logStruct(T value, Struct<T> struct) {
       if (struct.isImmutable()) {
         // log it directly
-        log(m_path, new LogStructValue<T>(value, struct));
+        log(this, new LogStructValue<T>(value, struct));
       } else if (struct.isCloneable()) {
         T clonedValue;
         try {
@@ -107,20 +158,20 @@ public <T> void logStruct(T value, Struct<T> struct) {
           throw new UnsupportedOperationException(
               "struct.isCloneable() returned true, but clone() raised exception");
         }
-        log(m_path, new LogStructValue<T>(clonedValue, struct));
+        log(this, new LogStructValue<T>(clonedValue, struct));
       } else {
         // log it directly, but warn
         System.err.println(
             "warning: logging non-immutable and non-cloneable struct to '" + m_path + "'");
-        log(m_path, new LogStructValue<T>(value, struct));
+        log(this, new LogStructValue<T>(value, struct));
       }
     }
 
     @Override
     public <T> void logProtobuf(T value, Protobuf<T, ?> proto) {
       if (proto.isImmutable()) {
         // log it directly
-        log(m_path, new LogProtobufValue<T>(value, proto));
+        log(this, new LogProtobufValue<T>(value, proto));
       } else if (proto.isCloneable()) {
         T clonedValue;
         try {
@@ -129,20 +180,20 @@ public <T> void logProtobuf(T value, Protobuf<T, ?> proto) {
           throw new UnsupportedOperationException(
               "proto.isCloneable() returned true, but clone() raised exception");
         }
-        log(m_path, new LogProtobufValue<T>(clonedValue, proto));
+        log(this, new LogProtobufValue<T>(clonedValue, proto));
       } else {
         // log it directly, but warn
         System.err.println(
             "warning: logging non-immutable and non-cloneable proto to '" + m_path + "'");
-        log(m_path, new LogProtobufValue<T>(value, proto));
+        log(this, new LogProtobufValue<T>(value, proto));
       }
     }
 
     @Override
     public <T> void logStructArray(T[] value, Struct<T> struct) {
       if (struct.isImmutable()) {
         // log it directly
-        log(m_path, new LogStructArrayValue<T>(value.clone(), struct));
+        log(this, new LogStructArrayValue<T>(value.clone(), struct));
       } else if (struct.isCloneable()) {
         @SuppressWarnings("unchecked")
         T[] clonedArray = (T[]) Array.newInstance(struct.getClass(), value.length);
@@ -154,90 +205,91 @@ public <T> void logStructArray(T[] value, Struct<T> struct) {
           throw new UnsupportedOperationException(
               "struct.isCloneable() returned true, but clone() raised exception");
         }
-        log(m_path, new LogStructArrayValue<T>(clonedArray, struct));
+        log(this, new LogStructArrayValue<T>(clonedArray, struct));
       } else {
         // log it directly, but warn
         System.err.println(
             "warning: logging non-immutable and non-cloneable struct to '" + m_path + "'");
-        log(m_path, new LogStructArrayValue<T>(value.clone(), struct));
+        log(this, new LogStructArrayValue<T>(value.clone(), struct));
       }
     }
 
     @Override
     public void logBoolean(boolean value) {
-      log(m_path, value);
+      log(this, value);
     }
 
     @Override
     public void logShort(short value) {
-      log(m_path, value);
+      log(this, value);
     }
 
     @Override
     public void logInt(int value) {
-      log(m_path, value);
+      log(this, value);
     }
 
     @Override
     public void logLong(long value) {
-      log(m_path, value);
+      log(this, value);
     }
 
     @Override
     public void logFloat(float value) {
-      log(m_path, value);
+      log(this, value);
     }
 
     @Override
     public void logDouble(double value) {
-      log(m_path, value);
+      log(this, value);
     }
 
     @Override
     public void logString(String value, String typeString) {
-      log(m_path, new LogStringValue(value, typeString));
+      log(this, new LogStringValue(value, typeString));
     }
 
     @Override
     public void logBooleanArray(boolean[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logShortArray(short[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logIntArray(int[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logLongArray(long[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logFloatArray(float[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logDoubleArray(double[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logStringArray(String[] value) {
-      log(m_path, value.clone());
+      log(this, value.clone());
     }
 
     @Override
     public void logRaw(byte[] value, String typeString) {
-      log(m_path, new LogRawValue(value.clone(), typeString));
+      log(this, new LogRawValue(value.clone(), typeString));
     }
 
     private final String m_path;
+    private int m_last = -1;
   }
 }