Array.h

Go to the documentation of this file.

/*
 * This is a part of the Uniot project.
 * Copyright (C) 2016-2024 Uniot <contact@uniot.io>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


 
#pragma once
 
#include <Arduino.h>
 
#include <new>
#include <type_traits>
#include <utility>
 
namespace uniot {
template <typename T>
class Array {
 public:
  Array() : mData(nullptr), mSize(0), mCapacity(0) {}

  Array(size_t capacity) : mData(nullptr), mSize(0), mCapacity(0) {
    reserve(capacity);
  }

  Array(size_t size, const T* values) : mData(nullptr), mSize(0), mCapacity(0) {
    if (values && size > 0) {
      mData = new (std::nothrow) T[size];
      if (!mData) {
        return;
      }
 
      if constexpr (std::is_trivially_copyable<T>::value) {
        memcpy(reinterpret_cast<void*>(mData), values, sizeof(T) * size);
      } else {
        for (size_t i = 0; i < size; ++i) {
          mData[i] = values[i];
        }
      }
 
      mSize = size;
      mCapacity = size;
    }
  }

  Array(const Array& other) = delete;

  Array(Array&& other) noexcept
      : mData(other.mData), mSize(other.mSize), mCapacity(other.mCapacity) {
    other.mData = nullptr;
    other.mSize = 0;
    other.mCapacity = 0;
  }

  Array& operator=(const Array& other) = delete;

  Array& operator=(Array&& other) noexcept {
    if (this != &other) {
      delete[] mData;
 
      mData = other.mData;
      mSize = other.mSize;
      mCapacity = other.mCapacity;
 
      other.mData = nullptr;
      other.mSize = 0;
      other.mCapacity = 0;
    }
    return *this;
  }

  ~Array() {
    delete[] mData;
    mData = nullptr;
    mSize = 0;
    mCapacity = 0;
  }

  T& operator[](size_t index) {
    return mData[index];
  }

  const T& operator[](size_t index) const {
    return mData[index];
  }

  bool get(size_t index, T& outValue) const {
    if (index < mSize) {
      outValue = mData[index];
      return true;
    }
    return false;
  }

  bool set(size_t index, const T& value) {
    if (index < mSize) {
      mData[index] = value;
      return true;
    }
    return false;
  }

  size_t size() const { return mSize; }

  size_t capacity() const { return mCapacity; }

  bool isEmpty() const { return mSize == 0; }

  const T* raw() const { return mData; }

  bool reserve(size_t newCapacity) {
    if (newCapacity <= mCapacity) {
      return true;
    }
 
    T* new_data = new (std::nothrow) T[newCapacity];
    if (!new_data) {
      return false;
    }
 
    // Move existing elements
    for (size_t i = 0; i < mSize; ++i) {
      new_data[i] = std::move(mData[i]);
    }
 
    // Initialize new elements
    if constexpr (std::is_trivially_default_constructible<T>::value) {
      memset(reinterpret_cast<void*>(new_data + mSize), 0, sizeof(T) * (newCapacity - mSize));
    } else {
      for (size_t i = mSize; i < newCapacity; ++i) {
        new_data[i] = T();
      }
    }
 
    delete[] mData;
    mData = new_data;
    mCapacity = newCapacity;
    return true;
  }

  bool push(const T& value) {
    if (mSize >= mCapacity) {
      size_t newCapacity = (mCapacity == 0) ? 1 : mCapacity * 2;
      if (!reserve(newCapacity)) {
        return false;
      }
    }
    mData[mSize++] = value;
    return true;
  }

  bool push(T&& value) {
    if (mSize >= mCapacity) {
      size_t newCapacity = (mCapacity == 0) ? 1 : mCapacity * 2;
      if (!reserve(newCapacity)) {
        return false;
      }
    }
    mData[mSize++] = std::move(value);
    return true;
  }

  void clear() {
    // if constexpr (!std::is_trivially_destructible<T>::value) {
    //   for (size_t i = 0; i < mSize; ++i) {
    //     mData[i].~T();
    //   }
    // }
    mSize = 0;
  }

  bool shrink() {
    if (mCapacity == mSize) {
      return true;
    }
 
    T* new_data = nullptr;
    if (mSize > 0) {
      new_data = new (std::nothrow) T[mSize];
      if (!new_data) {
        return false;
      }
 
      for (size_t i = 0; i < mSize; ++i) {
        new_data[i] = std::move(mData[i]);
      }
    }
 
    // if constexpr (!std::is_trivially_destructible<T>::value) {
    //   for (size_t i = mSize; i < mCapacity; ++i) {
    //     mData[i].~T();
    //   }
    // }
 
    delete[] mData;
    mData = new_data;
    mCapacity = mSize;
    return true;
  }
 
 private:
  T* mData;
  size_t mSize;
  size_t mCapacity;
};

}  // namespace uniot