KV_Iterator.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef ARDUINO
 
#include <KVComm/include/KVComm/KV_Error.hpp> // KV_ERROR
#include <KVComm/include/KVComm/KV_Helpers.hpp> // nextWord, roundUpToWordSizeMultiple
#include <KVComm/include/KVComm/KV_Types.hpp> // KV_Type<T>
 
#include <AH/STL/array>    // std::array
#include <AH/STL/cstddef>  // size_t
#include <AH/STL/cstdint>  // uint8_t, uint16_t
#include <AH/STL/iterator> // iterator traits
#include <AH/STL/vector>   // std::vector
 
#include <WString.h>
 
#else
 
#include <KVComm/KV_Error.hpp>   // KV_ERROR
#include <KVComm/KV_Helpers.hpp> // nextWord, roundUpToWordSizeMultiple
#include <KVComm/KV_Types.hpp>   // KV_Type<T>
 
#include <array>    // std::array
#include <cstddef>  // size_t
#include <cstdint>  // uint8_t, uint16_t
#include <iterator> // iterator traits
#include <vector>   // std::vector
 
#endif
 
 
class KV_Iterator {
  public:
    KV_Iterator(const uint8_t *buffer, size_t length)
        : buffer(buffer), bufferSize(length) {}
 
    class KV {
      public:
        KV(const uint8_t *buffer) : buffer(buffer) {}
        uint8_t getTypeID() const { return buffer[1]; }
        uint16_t getIDLength() const { return buffer[0]; }
        uint16_t getDataLength() const {
            return (buffer[2] << 0) | (buffer[3] << 8);
        }
        const uint8_t *getBuffer() const { return buffer; }
        const char *getID() const { return (const char *) buffer + 4; }
        const uint8_t *getData() const {
            return buffer + nextWord(getIDLength()) + 4;
        }
        explicit operator bool() const { return buffer != nullptr; }
 
        template <class T>
        uint16_t getArraySize() const {
            return getDataLength() / KV_Type<T>::getLength();
        }
 
        template <class T>
        void get(T &t, size_t index = 0) const {
            if (!*this) {
                KV_ERROR(F("Trying to extract data from non-existent entry"),
                         0x7566);
                return; // LCOV_EXCL_LINE
            }
            if (!checkType<T>())
                return; // LCOV_EXCL_LINE
            if (index * KV_Type<T>::getLength() >= getDataLength()) {
                KV_ERROR(F("Index out of range"), 0x7564);
                return; // LCOV_EXCL_LINE
            }
            auto readlocation = getData() + KV_Type<T>::getLength() * index;
            KV_Type<T>::readFromBuffer(t, readlocation);
        }
 
        template <class T>
        T getAs(size_t index = 0) const {
            T t;
            get(t, index);
            return t;
        }
 
        template <class T>
        std::vector<T> getVector() const {
            if (!*this) {
                KV_ERROR(F("Trying to extract data from non-existent entry"),
                         0x7566);
                return {}; // LCOV_EXCL_LINE
            }
            if (!checkType<T>())
                return {}; // LCOV_EXCL_LINE
            size_t size = getDataLength() / KV_Type<T>::getLength();
            std::vector<T> result(size);
            auto readlocation = getData();
            for (T &t : result) {
                KV_Type<T>::readFromBuffer(t, readlocation);
                readlocation += KV_Type<T>::getLength();
            }
            return result;
        }
 
        template <class T, size_t N>
        std::array<T, N> getArray() const {
            if (!*this) {
                KV_ERROR(F("Trying to extract data from non-existent entry"),
                         0x7566);
                return {{}}; // LCOV_EXCL_LINE
            }
            if (!checkType<T>())
                return {{}}; // LCOV_EXCL_LINE
            if (N * KV_Type<T>::getLength() != getDataLength()) {
                KV_ERROR(F("Incorrect length"), 0x7565);
                return {{}}; // LCOV_EXCL_LINE
            }
            std::array<T, N> result;
            auto readlocation = getData();
            for (T &t : result) {
                KV_Type<T>::readFromBuffer(t, readlocation);
                readlocation += KV_Type<T>::getLength();
            }
            return result;
        }
 
#if !defined(ARDUINO) || defined(DOXYGEN)
 
        std::string getString() const;
#else
        String getString() const;
#endif
 
        template <class T>
        bool hasType() const {
            return this->getTypeID() == KV_Type<T>::getTypeID();
        }
 
      protected:
        template <class T>
        bool checkType() const {
            if (!hasType<T>()) {
                KV_ERROR(F("Type mismatch (typeid=")
                             << getTypeID() << F(", conversion requested to ")
                             << KV_Type<T>::getTypeID() << ')',
                         0x7563);
                return false; // LCOV_EXCL_LINE
            }
            return true;
        }
 
      private:
        const uint8_t *buffer;
    };
 
    class iterator {
      public:
        iterator();
        iterator(const uint8_t *buffer, size_t length);
 
        iterator &operator++();
#if 0
        bool operator==(const iterator &other) const;
#endif
        bool operator!=(const iterator &other) const;
 
        const KV &operator*() const { return kv; }
        const KV *operator->() const { return &kv; }
 
        explicit operator bool() const { return !!kv; }
 
        using difference_type   = void;
        using value_type        = KV;
        using pointer           = KV *;
        using reference         = KV &;
        using iterator_category = std::input_iterator_tag;
 
      protected:
        void checkLength();
 
      private:
        KV kv;
        size_t remainingBufferLength;
    };
 
    iterator begin() const { return {buffer, bufferSize}; }
    static iterator end() { return {}; }
 
    iterator find(const char *key) const;
 
  private:
    const uint8_t *buffer;
    size_t bufferSize;
};
 
/// @}