ustd_array.h

// ustd_array.h - array class
 
#pragma once
 
#include "ustd_platform.h"
 
namespace ustd {
 
#define ARRAY_INC_SIZE 16
#define ARRAY_MAX_SIZE UINT_MAX  // 65535 or 4294967295 (mostly)
#define ARRAY_INIT_SIZE 16
 
// Helper class for array iterators:
template <typename T> class arrayIterator {
  private:
    T *values_ptr;
    unsigned int position;
 
  public:
    arrayIterator(T *values_ptr, unsigned int p) : values_ptr{values_ptr}, position{p} {
    }
 
    bool operator!=(const arrayIterator<T> &other) const {
        return !(*this == other);
    }
 
    bool operator==(const arrayIterator<T> &other) const {
        return position == other.position;
    }
 
    arrayIterator &operator++() {
        ++position;
        return *this;
    }
 
    T &operator*() const {
        return *(values_ptr + position);
    }
};
 
template <typename T> class array {
 
  private:
    T *arr;
    unsigned int startSize;
    unsigned int maxSize;
    unsigned int incSize = ARRAY_INC_SIZE;
    bool shrink = true;
    unsigned int allocSize;
    unsigned int size;
    T bad = {};
 
    T *ualloc(unsigned int n) {
#if defined(__ATTINY__)
        return (T *)malloc(n * sizeof(T));
#else
        return new T[n];
#endif
    }
    void ufree(T *p) {
#if defined(__ATTINY__)
        free(p);
#else
        delete[] p;
#endif
    }
 
  public:
    array(unsigned int startSize = ARRAY_INIT_SIZE, unsigned int maxSize = ARRAY_MAX_SIZE,
          unsigned int incSize = ARRAY_INC_SIZE, bool shrink = true)
        : startSize(startSize), maxSize(maxSize), incSize(incSize), shrink(shrink) {
        size = 0;
        if (maxSize < startSize)
            maxSize = startSize;
        allocSize = startSize;
        arr = ualloc(allocSize);  // new T[allocSize];
    }
 
    array(const T initarray[], unsigned int count) {
        allocSize = count;
        startSize = count;
        maxSize = ARRAY_MAX_SIZE;
        incSize = ARRAY_INC_SIZE;
        shrink = true;
        size = count;
        bad = {};
        arr = ualloc(allocSize);  // new T[allocSize];
        for (unsigned int i = 0; i < size; i++) {
            arr[i] = initarray[i];
        }
    }
 
    array(const array<T> &ar) {
        arr = ualloc(ar.allocSize);
        if (arr) {
            // memcpy(arr, ar.arr, ar.size * sizeof(T));
            startSize = ar.startSize;
            maxSize = ar.maxSize;
            incSize = ar.incSize;
            shrink = ar.shrink;
            allocSize = ar.allocSize;
            size = ar.size;
            bad = ar.bad;
            for (unsigned int i = 0; i < size; i++) {
                arr[i] = ar.arr[i];
            }
        }
    }
 
    ~array() {
        if (arr != nullptr) {
            ufree(arr);
            arr = nullptr;
        }
    }
 
    // iterators
    arrayIterator<T> begin() {
        return arrayIterator<T>(arr, 0);
    }
    arrayIterator<T> end() {
        return arrayIterator<T>(arr, 0 + size);
    }
 
    arrayIterator<const T> begin() const {
        return arrayIterator<const T>(arr, 0);
    }
 
    arrayIterator<const T> end() const {
        return arrayIterator<const T>(arr, 0 + size);
    }
 
    bool resize(unsigned int newSize) {
        unsigned int mv = newSize;
        if (newSize > maxSize) {
            if (maxSize == allocSize)
                return false;
            else
                newSize = maxSize;
        }
        if (!shrink) {
            if (newSize <= allocSize)
                return true;
        } else {
            if (newSize < allocSize)
                mv = newSize;
            else
                mv = allocSize;
        }
        T *arrn = ualloc(newSize ? newSize : ARRAY_INIT_SIZE);  // new T[newSize];
        if (arrn == nullptr)
            return false;
        for (unsigned int i = 0; i < mv; i++) {
            arrn[i] = arr[i];
        }
        ufree(arr);
        arr = arrn;
        allocSize = newSize ? newSize : ARRAY_INIT_SIZE;
        if (newSize < size)
            size = newSize;
        return true;
    }
 
    void setInvalidValue(T &entryInvalidValue) {
        bad = entryInvalidValue;
    }
 
    int add(T &entry) {
        if (size >= allocSize) {
            if (incSize == 0)
                return -1;
            if (!resize(allocSize + incSize))
                return -1;
        }
        arr[size] = entry;
        ++size;
        return size - 1;
    }
 
    bool erase(unsigned int index) {
        if (index >= size) {
            return false;
        }
        for (unsigned int i = index; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
        --size;
        if (shrink) {
            if ((size < allocSize - incSize) && (allocSize > incSize)) {
                resize(allocSize - incSize);
            }
        }
        return true;
    }
 
    bool erase() {
        return resize(0);
    }
 
    T operator[](unsigned int i) const {
        if (i >= size) {
#if defined (__UNIXOID__)
            assert(i < size);
#endif
            return bad;
        }
        return arr[i];
    }
 
    T &operator[](unsigned int i) {
        if (i >= allocSize) {
#if defined(__UNIXOID__)
            if (incSize == 0) {
                assert(i < allocSize);
            }
#endif
            if (!resize(allocSize + incSize)) {
#if defined(__UNIXOID__)
                assert(i < allocSize);
#endif
            }
        }
        if (i >= size && i <= allocSize)
            size = i + 1;
        if (i >= allocSize) {
            return bad;
        }
        return arr[i];
    }
 
    bool isEmpty() const {
        if (size == 0)
            return true;
        else
            return false;
    }
 
    unsigned int length() const {
        return (size);
    }
    unsigned int alloclen() const {
        return (allocSize);
    }
};
}  // namespace ustd