Move collections to namespace for better management of names.

Author: davetcc

README.md

@@ -25,6 +25,8 @@ Use the platformIO library manager to get the library. It's called 'SimpleCollec
 
 We must understand that this list is associative and sorted by a key, it is based on a binary search algorithm, so it is relatively slow to insert into the underlying array as it will need to be inserted into the array at the right point. However, in return for this, lookup by key is very fast - in big-O notation it is approximately Log(N) or in simple terms to look up in a 256 item list by key would take maximum 8 iterations. However, insertion carries a possible copy penalty if the items need reordering.
 
+All collections in this library are in the namespace tccollection, by default SimpleCollection.h adds a statement to use this namespace automatically.
+
 ### Restrictions on what you put in the list
 
 This list works by copying items into the list, so the things you store must follow a couple of simple rules.
@@ -125,9 +127,9 @@ There is an example that shows the usage of the circular buffer, but the API is
 We first create an instance and indicate the size needed, the size is fixed and if the writer exceeds the reader, it will wrap and data is lost.
 
     #include <SimpleCollections.h>
-    #include <CircularBuffer.h>
+    #include <SCCircularBuffer.h>
 
-    CircularBuffer buffer(20);
+    SCCircularBuffer buffer(20);
 
 ### Writing to the buffer
 

examples/circularBuffer/circularBuffer.ino

@@ -10,11 +10,11 @@
 
 #include <Arduino.h>
 #include <SimpleCollections.h>
-#include <CircularBuffer.h>
+#include <SCCircularBuffer.h>
 
 #define INTERRUPT_PIN 2
 
-CircularBuffer buffer(32);
+SCCircularBuffer buffer(32);
 
 volatile uint8_t counter = 0;
 

examples/mbedExample/mbedExample.cpp

@@ -20,6 +20,7 @@
 
 #include <mbed.h>
 #include <SimpleCollections.h>
+#include <SCCircularBuffer.h>
 
 BufferedSerial console(USBTX, USBRX, 115200);
 
@@ -46,7 +47,20 @@ class MbedStorage {
 };
 
 BtreeList<uint32_t, MbedStorage> myList;
+SCCircularBuffer buffer(20);
+Thread bufferWriter;
+volatile bool running = true;
 
+//
+// Yet another thread that constantly raises events to test thread safety of task manager.
+//
+uint8_t loopCounter = 0;
+void bufferWriterThreadProc() {
+    while(running) {
+        ThisThread::sleep_for(500ms);
+        buffer.put(loopCounter++);
+    }
+}
 
 void log(const char* toLog) {
     console.write(toLog, strlen(toLog));
@@ -60,26 +74,35 @@ int main() {
     myList.add(MbedStorage("Aloha"));
     myList.add(MbedStorage(frenchWelcome));
 
-    while(1) {
-        log("Iterate list using C++ range");
-        for (auto d: myList) {
-            log(d.getData());
-        }
+    log("Iterate list using C++ range");
+    for (auto d: myList) {
+        log(d.getData());
+    }
 
-        log("Iterate list using forEach");
-        myList.forEachItem([](MbedStorage *storage) {
-            log(storage->getData());
-        });
+    log("Iterate list using forEach");
+    myList.forEachItem([](MbedStorage *storage) {
+        log(storage->getData());
+    });
+
+    log("Find an item by key");
+    auto toCheck = myList.getByKey(frenchWelcome.getKey());
+    if (toCheck && toCheck->getKey() == frenchWelcome.getKey()) {
+        log("Found item using key");
+    } else {
+        log("Find by key failed");
+    }
+
+    bufferWriter.start(bufferWriterThreadProc);
 
-        log("Find an item by key");
-        auto toCheck = myList.getByKey(frenchWelcome.getKey());
-        if (toCheck && toCheck->getKey() == frenchWelcome.getKey()) {
-            log("Found item using key");
-        } else {
-            log("Find by key failed");
-        }
 
-        ThisThread::sleep_for(2000ms);
+    while(1) {
+        if(buffer.available()) {
+            log("received buffer");
+            char sz[50];
+            sprintf(sz, "received buffer %i", buffer.get());
+            log(sz);
+        }
+        ThisThread::sleep_for(100ms);
     }
     return 0;
 }

src/CircularBuffer.cpp src/SCCircularBuffer.cppsrc/CircularBuffer.cpp renamed to src/SCCircularBuffer.cpp

@@ -3,15 +3,17 @@
  * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
  */
 
-#include "CircularBuffer.h"
+#include "SCCircularBuffer.h"
 
-CircularBuffer::CircularBuffer(uint16_t size) : readerPosition(0), writerPosition(0), bufferSize(size), buffer(new uint8_t[size]) {}
+using namespace tccollection;
 
-CircularBuffer::~CircularBuffer() {
+SCCircularBuffer::SCCircularBuffer(uint16_t size) : readerPosition(0), writerPosition(0), bufferSize(size), buffer(new uint8_t[size]) {}
+
+SCCircularBuffer::~SCCircularBuffer() {
     delete[] buffer;
 }
 
-uint16_t CircularBuffer::nextPosition(position_ptr_t positionPtr) {
+uint16_t SCCircularBuffer::nextPosition(position_ptr_t positionPtr) {
     bool successfullyUpdated = false;
     position_t existing;
     while(!successfullyUpdated) {

src/CircularBuffer.h src/SCCircularBuffer.hsrc/CircularBuffer.h renamed to src/SCCircularBuffer.h

@@ -14,7 +14,8 @@
 typedef volatile uint32_t* position_ptr_t;
 typedef volatile uint32_t position_t;
 inline bool casAtomic(position_ptr_t ptr, position_t expected, position_t newVal) {
-    return core_util_atomic_cas_u32(ptr, &expected, newVal);
+    uint32_t exp = expected;
+    return core_util_atomic_cas_u32(ptr, &exp, newVal);
 }
 inline uint16_t readAtomic(position_ptr_t ptr) { return *(ptr); }
 #elif defined(ESP8266)
@@ -56,31 +57,41 @@ inline bool casAtomic(position_ptr_t ptr, position_t expected, position_t newVal
 inline uint16_t readAtomic(position_ptr_t ptr) { return *ptr; }
 #endif
 
+namespace tccollection {
+
 /**
  * Create a circular buffer that has a fixed size and can be filled and read at the same time one character at a time.
- * It is very thread safe on ESP32 and mbed based boards, it is moderately thread safe on other boards.
+ * It is very thread safe on ESP32 and mbed based boards, it is thread safe on other boards, unless you are using that
+ * board with an unexpected RTOS, in which case you would need to determine suitability yourself.
  *
  * Imagine the buffer like a circle with a given number of segments, both the reader and writer pointers start at 0.
  * As the data structure fills up the writer will move around, and the reader can try and "keep up". Once the reader
  * or writer gets to the end it will go back to 0 (start). This is by design and therefore, IT'S POSSIBLE TO LOSE DATA.
  */
-class CircularBuffer {
-private:
-    position_t readerPosition;
-    position_t writerPosition;
-    const uint16_t bufferSize;
-    uint8_t *const buffer;
-
-public:
-    explicit CircularBuffer(uint16_t size);
-    ~CircularBuffer();
-
-    bool available() const { return readerPosition != writerPosition; }
-    void put(uint8_t by) { buffer[nextPosition(&writerPosition)] = by;}
-    uint8_t get() { return buffer[nextPosition(&readerPosition)]; }
-private:
-    uint16_t nextPosition(position_ptr_t by);
-};
+    class SCCircularBuffer {
+    private:
+        position_t readerPosition;
+        position_t writerPosition;
+        const uint16_t bufferSize;
+        uint8_t *const buffer;
+
+    public:
+        explicit SCCircularBuffer(uint16_t size);
+
+        ~SCCircularBuffer();
+
+        bool available() const { return readerPosition != writerPosition; }
+
+        void put(uint8_t by) { buffer[nextPosition(&writerPosition)] = by; }
+
+        uint8_t get() { return buffer[nextPosition(&readerPosition)]; }
+
+    private:
+        uint16_t nextPosition(position_ptr_t by);
+    };
+
+}
+
 
 
 #endif //SIMPLECOLLECTIONS_CIRCULARBUFFER_H

src/SimpleCollections.cpp

@@ -9,9 +9,9 @@
 #include <malloc.h>
 #endif
 #include "SimpleCollections.h"
-#include <IoLogging.h>
 
 using namespace ioaTreeInternal;
+using namespace tccollection;
 
 BtreeStorage::BtreeStorage(bsize_t size, GrowByMode howToGrow, bsize_t itemSize, KeyAccessor keyAccess, CopyOperator copyOperator) {
     currentCapacity = size;
@@ -66,8 +66,6 @@ void BtreeStorage::removeIndex(bsize_t index) {
     // given the insert position, work out the number of items to move
     int amtToMove = (currentSize - index) - 1;
 
-    serdebugF4("remove ", amtToMove, index, currentCapacity);
-
     // move the instances in reverse order using their assignment operator.
     if(amtToMove > 0) {
         for (bsize_t i = index; i < index + amtToMove; ++i) {