Container.h

Go to the documentation of this file.

#ifndef Container_h
#define Container_h
 
// Local include.
#include "Helper.h"
 
// Library includes.
#include <assert.h>
 
 
#if THINGSBOARD_ENABLE_DYNAMIC
template <typename T>
#else 
template <typename T, size_t Capacity>
#endif // THINGSBOARD_ENABLE_DYNAMIC
class Container {
  public:
    using value_type = T;
    using size_type = size_t;
    using reference = T &;
    using const_reference = T const &;
    using pointer = T *;
    using const_pointer = T const *;
    using iterator = pointer;
    using const_iterator = const_pointer;
 
#if THINGSBOARD_ENABLE_DYNAMIC
    Container() = default;
 
    ~Container() {
        delete[] m_elements;
    }
 
    Container(Container const & other)
        : m_elements{}
        , m_capacity{other.m_capacity}
        , m_size{0U} {
        m_elements = new T[m_capacity]{};
        assign(other);
    }
 
    Container & operator=(Container const & other) {
        if (&other != this) {
            delete[] m_elements;
            m_elements = new T[other.m_capacity]{};
            m_capacity = other.m_capacity;
            m_size = 0U;
            assign(other);
        }
        return *this;
    }
#else
    Container()
      : m_elements()
      , m_size(0U)
    {
        static_assert(Capacity > 0);
    }
#endif // THINGSBOARD_ENABLE_DYNAMIC
 
    Container(size_type count, const_reference value = T{})
      : Container()
    {
        for (; count > 0; --count) {
            push_back(value);
        }
    }
 
    template<typename InputIterator>
    Container(InputIterator const & first, InputIterator const & last)
      : Container()
    {
        assign(first, last);
    }
 
    template<typename Iterable_Container>
    Container(Iterable_Container const & container)
      : Container(container.cbegin(), container.cend())
    {
        // Nothing to do
    }
 
    template<typename InputIterator>
    void assign(InputIterator const & first, InputIterator const & last) {
        insert(end(), first, last);
    }
 
    template<typename Container>
    void assign(Container const & container) {
        assign(container.cbegin(), container.cend());
    }
 
    bool empty() const {
        return m_size == 0U;
    }
 
    size_type size() const {
        return m_size;
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    size_type capacity() const {
        return m_capacity;
#else
    size_type constexpr capacity() const {
        return Capacity;
#endif // THINGSBOARD_ENABLE_DYNAMIC
    }
 
    iterator begin() {
        return m_elements;
    }
 
    const_iterator begin() const {
        return m_elements;
    }
 
    const_iterator cbegin() const {
        return begin();
    }
 
    reference front() {
        assert(m_size != 0U);
        return m_elements[0U];
    }
 
    const_reference front() const {
        assert(m_size != 0U);
        return m_elements[0U];
    }
 
    reference back() {
        assert(m_size != 0U);
        return m_elements[m_size - 1U];
    }
 
    const_reference back() const {
        assert(m_size != 0U);
        return m_elements[m_size - 1U];
    }
 
    iterator end() {
        return m_elements + m_size;
    }
 
    const_iterator end() const {
        return m_elements + m_size;
    }
 
    const_iterator cend() const {
        return end();
    }
 
    void push_back(const_reference element) {
#if THINGSBOARD_ENABLE_DYNAMIC
        increase_capacity();
#else
        assert(m_size < Capacity);
#endif // THINGSBOARD_ENABLE_DYNAMIC
        if (is_destructible()) {
            m_elements[m_size].~T();
        }
        m_elements[m_size] = element;
        m_size++;
    }
 
    template<typename InputIterator>
    void insert(iterator position, InputIterator const & first, InputIterator const & last) {
        (void)--position;
        assert_iterator_in_range(position);
#if !THINGSBOARD_ENABLE_DYNAMIC
        assert((m_size + Helper::distance(first, last)) < Capacity);
#endif // !THINGSBOARD_ENABLE_DYNAMIC
        for (auto it = first; it != last; ++it, ++position) {
#if THINGSBOARD_ENABLE_DYNAMIC
            increase_capacity();
#endif // THINGSBOARD_ENABLE_DYNAMIC
            if (is_destructible()) {
                (*position).~T();
            }
            *position = *it;
            (void)++m_size;
        }
    }
 
    void erase(const_iterator position) {
        assert_iterator_in_range(position);
        size_type const index = Helper::distance(cbegin(), position);
        // Move all elements after the index one position to the left
        for (size_type i = index; i <= m_size; ++i) {
            if (is_destructible()) {
                m_elements[i].~T();
                m_elements[i] = m_elements[i + 1];
            }
        }
        if (is_destructible()) {
            m_elements[m_size].~T();
        }
        // Decrease the size of the array to remove the last element, because either it was moved one index to the left or was the element we wanted to delete anyway
        (void)--m_size;
    }
 
    reference at(size_type const & index) {
        assert(index < m_size);
        return m_elements[index];
    }
 
    const_reference at(size_type const & index) const {
        assert(index < m_size);
        return m_elements[index];
    }
 
    reference operator[](size_type index) {
        return m_elements[index];
    }
 
    const_reference operator[](size_type index) const {
        return m_elements[index];
    }
 
    void clear() {
        m_size = 0;
    }
 
  private:
    bool is_destructible() const {
#if THINGSBOARD_ENABLE_STL
        return std::is_destructible<T>::value;
#else
        // Workaround for ArduinoJson version after 6.21.0, to still be able to access internal enable_if and is_floating_point declarations, previously accessible with ARDUINOJSON_NAMESPACE
        return ArduinoJson::ARDUINOJSON_VERSION_NAMESPACE::detail::is_class<T>::value;
#endif // THINGSBOARD_ENABLE_CXX20
    }
 
    void assert_iterator_in_range(const_iterator position) {
        assert(cbegin() >= position);
        assert(position < cend());
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    void increase_capacity() {
        if (m_size == m_capacity) {
            m_capacity = (m_capacity == 0) ? 1 : 2 * m_capacity;
            T* new_elements = new T[m_capacity]();
            if (m_elements != nullptr) {
                memcpy(new_elements, m_elements, m_size * sizeof(T));
                delete[] m_elements;
            }
            m_elements = new_elements;
        }
    }
#endif // THINGSBOARD_ENABLE_DYNAMIC
 
#if THINGSBOARD_ENABLE_DYNAMIC
    value_type *m_elements = {}; // Pointer to the start of our elements
    size_t     m_capacity = {};  // Allocated capacity that shows how many elements we could hold
#else
    value_type m_elements[Capacity] = {}; // Underlying c-array holding our data
#endif // THINGSBOARD_ENABLE_DYNAMIC
    size_type  m_size = {};               // Used size that shows how many elements we entered
};
 
#endif // Container_h