Add templatized Table implementation

Author: ianfixes

CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Pins now accept an array (or string) of input bits for providing pin values across multiple reads
 - FlashStringHelper (and related macros) compilation mocks
 - SoftwareSerial.  That took a while.
+- Queue template implementation
+- Table template implementation
 
 ### Changed
 - Unit test executables print to STDERR just in case there are segfaults.  Uh, just in case I ever write any.

SampleProjects/TestSomething/test/table.cpp

@@ -0,0 +1,74 @@
+#include <ArduinoUnitTests.h>
+#include <WString.h>
+#include <ci/Table.h>
+
+// for testing a work function
+// note swapped args because as "isMatch", it's "firstArg, key"
+bool isSubstr(String firstArg, String haystack) {
+  return strstr(haystack.c_str(), firstArg.c_str());
+}
+
+// for testing a work function
+int results[5];
+void setResult2(int k, int v) {
+  results[k] = v;
+}
+void setResult3(long l, int k, int v) {
+  results[k] = v + l;
+}
+
+
+unittest(basic_table)
+{
+  Table<String, int> t;
+  assertTrue(t.empty());
+
+  int data[5] = {11, 22, 33, 44, 55};
+
+  for (int i = 0; i < 5; ++i) {
+    assertEqual(i, t.size());
+    assertTrue(t.add(String(data[i]), data[i]));
+    assertEqual(i + 1, t.size());
+  }
+
+  assertTrue(t.has("44"));
+  assertFalse(t.has("66"));
+  assertEqual(44, t.get("44"));
+
+  assertEqual("33", t.getMatchingKey(String("3"), isSubstr));
+
+  for (int i = 0; i < 5; ++i) {
+    assertEqual(5 - i, t.size());
+    assertTrue(t.remove(String(data[i])));
+    assertFalse(t.has(String(data[i])));
+    assertEqual(4 - i, t.size());
+  }
+
+}
+
+unittest(iteration_no_arg) {
+  Table<int, int> t;
+  for (int i = 0; i < 5; ++i) {
+    results[i] = 0;
+    t.add(i, 11 * (i + 1));
+  }
+
+  t.iterate(&setResult2);
+
+  for (int i = 0; i < 5; ++i) assertEqual(11 * (i + 1), results[i]);
+}
+
+unittest(iteration_one_arg) {
+  Table<int, int> t;
+  for (int i = 0; i < 5; ++i) {
+    results[i] = 0;
+    t.add(i, 11 * (i + 1));
+  }
+
+  long offset = 9;
+  t.iterate(&setResult3, offset);
+
+  for (int i = 0; i < 5; ++i) assertEqual(11 * (i + 1), results[i] - offset);
+}
+
+unittest_main()

cpp/arduino/ci/Table.h

@@ -0,0 +1,125 @@
+#pragma once
+
+// A template-ized lookup table implementation
+//
+// this is this stupidest table implementation ever but it's
+// an MVP for unit testing. O(n).
+template <typename K, typename V>
+class Table {
+  private:
+    struct Node {
+      K key;
+      V val;
+      Node *next;
+    };
+
+    Node* mStart;
+    unsigned long mSize;
+    // to alow const reference signatures, pre-allocate nil values
+    K mNilK;
+    V mNilV;
+
+    void init() {
+      mStart = NULL;
+      mSize = 0;
+    }
+
+  public:
+    Table() : mNilK(), mNilV() { init(); }
+
+    // number of things in the table
+    inline unsigned long size() const { return mSize; }
+
+    // whether there are no things
+    inline bool empty() const { return 0 == mSize; }
+
+    // whether there is a thing stored at the given key
+    bool has(K const key) const {
+      for (Node* p = mStart; p; p = p->next) {
+        if (p->key == key) return true;
+      }
+      return false;
+    }
+
+    // allow find operations on keys
+    template <typename T>
+    const K& getMatchingKey(T const firstArg, bool (*isMatch)(const T, const K)) const {
+        for (Node* p = mStart; p; p = p->next) {
+          if (isMatch(firstArg, p->key)) return p->key;
+        }
+        return mNilK;
+    }
+
+    // allow iteration over entire table, with a work function that takes key/value pairs
+    void iterate(void (*work)(const K&, const V&)) const {
+        for (Node* p = mStart; p; p = p->next) work(p->key, p->val);
+    }
+    void iterate(void (*work)(K, V)) const {
+        for (Node* p = mStart; p; p = p->next) work(p->key, p->val);
+    }
+
+    // allow iteration over entire table, with a work function that takes key/value pairs
+    // plus an initial argument. this enables member function passing (via workaround)
+    template <typename T>
+    void iterate(void (*work)(T&, const K&, const V&), T& firstArg) const {
+        for (Node* p = mStart; p; p = p->next) work(firstArg, p->key, p->val);
+    }
+
+    template <typename T>
+    void iterate(void (*work)(T&, K, V), T& firstArg) const {
+        for (Node* p = mStart; p; p = p->next) work(firstArg, p->key, p->val);
+    }
+
+    template <typename T>
+    void iterate(void (*work)(T, K, V), T firstArg) const {
+        for (Node* p = mStart; p; p = p->next) work(firstArg, p->key, p->val);
+    }
+
+    // return the value for a given key
+    const V& get(K const key) const {
+      for (Node* p = mStart; p; p = p->next) {
+        if (p->key == key) return p->val;
+      }
+      return mNilV;
+    }
+
+    // remove an item by key
+    bool remove(K const key) {
+      Node *o = NULL;
+      for (Node* p = mStart; p; p = p->next) {
+        if (p->key == key) {
+          (o ? o->next : mStart) = p->next;
+          delete p;
+          --mSize;
+          return true;
+        }
+        o = p;
+      }
+      return false;
+    }
+
+    // add a key/value pair.  deletes any existing key by that name.
+    bool add(K const key, V const val) {
+      remove(key);
+      Node *n = new Node;
+      if (n == NULL) return false;
+      n->key = key;
+      n->val = val;
+      n->next = mStart;
+      mStart = n;
+      ++mSize;
+      return true;
+    }
+
+    // remove everything
+    void clear() {
+      Node* p;
+      while (mStart) {
+        p = mStart;
+        mStart = mStart->next;
+        delete p;
+      }
+    }
+
+    ~Table() { clear(); }
+};