KV_Builder.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef ARDUINO
 
#include <KVComm/include/KVComm/KV_Iterator.hpp> // KV_Iterator
 
#include <AH/STL/array>            // std::array
#include <AH/STL/cstddef>          // size_t
#include <AH/STL/initializer_list> // std::initializer_list
#include <AH/STL/vector>           // std::vector
#include <string.h>                // strlen
 
#else
 
#include <KVComm/KV_Iterator.hpp> // KV_Iterator
 
#include <array>            // std::array
#include <cstddef>          // size_t
#include <cstring>          // strlen
#include <initializer_list> // std::initializer_list
#include <iosfwd>           // std::ostream forward declaration
#include <vector>           // std::vector
#endif
 
#if defined(ARDUINO) || defined(ARDUINO_TEST)
#include <Print.h>
#endif
 
 
class KV_Builder {
  public:
    KV_Builder(uint8_t *buffer, size_t bufferSize)
        : buffer(buffer), bufferSize(bufferSize) {}
 
    template <class T>
    bool add(const char *key, const T *data, size_t count) {
        // don't allow empty keys
        if (key == nullptr || key[0] == '\0')
            return false;
        // don't allow null data
        if (data == nullptr && count != 0)
            return false;
        // Check if dictionary already contains a value with this key
        KV_Iterator::iterator found = find(key);
        if (found != KV_Iterator::end())
            // if the dictionary already contains an element with the same key
            return overwrite(found, data, count);
        else
            // this is a new key
            return append(key, data, count);
    }
 
    template <class T>
    bool add(const char *key, const T &value) {
        return add(key, &value, 1);
    }
 
    bool add(const char *key, const char *data) {
        return add(key, data, strlen(data) + 1);
    }
 
    template <class T, size_t N>
    bool add(const char *key, const T (&array)[N]) {
        return add(key, array, N);
    }
 
    template <class T>
    bool add(const char *key, std::initializer_list<T> list) {
        return add(key, list.begin(), list.size());
    }
 
    template <class T, size_t N>
    bool add(const char *key, const std::array<T, N> &array) {
        return add(key, array.data(), N);
    }
 
    template <class T>
    bool add(const char *key, const std::vector<T> &vector) {
        return add(key, vector.data(), vector.size());
    }
 
    void clear() {
        bufferwritelocation = buffer;
        maxLen              = bufferSize;
        std::fill(buffer, buffer + bufferSize, 0);
    }
 
#if !defined(ARDUINO) || defined(DOXYGEN)
    void print(std::ostream &os) const;
    void printPython(std::ostream &os) const;
#endif // ARDUINO
 
#if defined(ARDUINO) || defined(ARDUINO_TEST) || defined(DOXYGEN)
 
    void print(Print &os) const;
 
    void printPython(Print &os) const;
#endif
 
  private:
    uint8_t *buffer;
    size_t bufferSize;
    size_t maxLen = bufferSize;
 
    uint8_t *bufferwritelocation = buffer;
 
  private:
    uint8_t *writeHeader(const char *key, uint8_t typeID, size_t length);
 
    template <class T>
    bool append(const char *key, const T *data, size_t count);
 
    template <class T>
    bool overwrite(KV_Iterator::iterator existing, const T *data, size_t count);
 
    template <class T>
    void overwrite(uint8_t *buffer, const T *data, size_t count);
 
  public:
    const uint8_t *getBuffer() const { return buffer; }
    size_t getBufferSize() const { return bufferSize; }
    size_t getLength() const { return getBufferSize() - maxLen; }
 
    void changeBuffer(uint8_t *buffer, size_t size) {
        this->buffer              = buffer;
        this->bufferwritelocation = buffer;
        this->bufferSize          = size;
        this->maxLen              = size;
    }
 
    KV_Iterator::iterator find(const char *key) const;
};
 
#define ADD_VAR(dict, var) dict.add(#var, var)
 
template <size_t N>
class Static_KV_Builder : public KV_Builder {
  public:
    Static_KV_Builder() : KV_Builder(nullptr, 0) {
        changeBuffer(buffer.data(), N);
    }
 
  private:
    std::array<uint8_t, N> buffer = {{}};
};
 
 
#include "KV_Builder.ipp"