flatarray.h

#pragma once
#include <tuple>
 
template <typename TupleT, typename Fn>
void for_each_tuple(TupleT&& tp, Fn&& fn) {
    std::apply(
        [&fn](auto&& ...args)
        {
            (fn(std::forward<decltype(args)>(args)), ...);
        }, std::forward<TupleT>(tp)
        );
}
 
template <class T> class FlatArrayVec : public std::vector<T> {
public:
    typedef uint64  size_type;
    FlatArrayVec() { }
    FlatArrayVec(size_type s,double =1.3) : defaultStorage_(s) { this->reserve(defaultStorage_); }
    FlatArrayVec(const FlatArrayVec<T> &f) { operator=(f); }
    FlatArrayVec(std::initializer_list<T> l) {
        for (auto it=l.begin();it!=l.end();++it)
            push_back(*it);
    }
    using std::vector<T>::reserve;
    using std::vector<T>::assign;
    const FlatArrayVec<T> &operator=(const FlatArrayVec<T> &f) {
        defaultStorage_ = f.defaultStorage_;
        this->clear();
        reserve(f.capacity());
        if constexpr (std::is_copy_assignable<T>::value)
            assign(f.begin(),f.end());
        else
            throw Exception("Internal Error: Attempting to copy a vector who's members are not copyable (like an owned pointer)");
        return *this;
    }
    const size_type &allocated() const { return this->capacity(); }
    size_type removeReplaceLast(size_type i) {
        if (i>=this->size())
            throw Exception("RemoveReplaceLast failed");
        std::swap(this->at(i),this->back());
        this->pop_back();
        return this->size();
    }
    size_type removeReplaceLastClip(size_type i) {
        size_type ret = removeReplaceLast(i);
        this->shrink_to_fit();
        return ret;
    }
 
    bool remove(size_type i) {
        if (i>=this->size())
            throw Exception("Remove failed");
        this->erase(i);
        return true;
    }
    size_type removeAll(const T &t) {
        size_type ret = 0;
        for (size_type i=0;i<this->size();) {
            if (t==this->at(i)) {
                remove(i);
                ++ret;
            } else
                ++i;
        }
        return ret;
    }
    void reset() {
        this->clear();
        if (defaultStorage_ != this->capacity()) {
            this->shrink_to_fit();
            this->reserve(defaultStorage_);
        }
    }
    void clip() { this->shrink_to_fit(); }
    const T & operator[] (const int nIndex) const {
        try {
#ifdef _DEBUG
            if (nIndex >= (int)this->size() or nIndex < 0)
                throw Exception("Size check failed in FlatArrayVec");
#endif
            return std::vector<T>::operator[](nIndex);
        } catch (...) {
            throw;
        }
    }
    
    T & operator[] (const int nIndex) {
        try {
#ifdef _DEBUG
            if (nIndex >= (int)this->size() or nIndex < 0)
                throw Exception("Size check failed in FlatArrayVec");
#endif
            return std::vector<T>::operator[](nIndex);
        } catch (...) {
            throw;
        }
    }
private:
    size_type defaultStorage_ = 1000;
};
// EoF