farray.h

Go to the documentation of this file.

#pragma once
#include "basetoqt.h"
 
template <typename T, uint64 S = 32>
class FArray {
public:
 using size_type = uint64; 
 using value_type = T; 
 using iterator = T *; 
 using const_iterator = const T *; 
 
 FArray() {}
 explicit FArray(size_type s, const T &t = T());
 template <uint64 S2> FArray(const FArray<T, S2> &f) { operator=(f); }
 FArray(const FArray<T, S> &f) { operator=(f); }
 FArray(std::initializer_list<T> l);
 ~FArray() { reset(); }
 const FArray<T,S> &operator=(const FArray<T,S> &f);
 template <uint64 S2> const FArray<T, S> &operator=(const FArray<T, S2> &f);
 template <uint64 S2> bool operator==(const FArray<T,S2> &f) const;
 
 // Accessors
 size_type size() const { return end_ - begin_; }
 size_type stackSize() const { return S; }
 size_type allocated() const { return capacity_ - begin_; }
 bool empty() const { return end_ == begin_; }
 T *data() { return begin_; }
 const T *data() const { return begin_; }
 T &front() { return *begin_; }
 const T &front() const { return *begin_; }
 T &back() { return *(end_ - 1); }
 const T &back() const { return *(end_ - 1); }
 size_type find(const T &t) const;
 size_type capacity() const { return capacity_ - begin_; }
 
 // Manipulators
 void push_back(const T &t) { checkAllocated(size() + 1); new(end_) T(t); ++end_; }
 T *emplace_back() { checkAllocated(size() + 1); return end_++; }
 T *emplace_n_back(uint64 n);
 void pop_back() { assert(size()); --end_; end_->~T(); }
 void resize(size_type i, const T &t = T());
 iterator insert(size_type i, const T &t);
 void put(size_type i, const T &t);
 template <class C> void append(const C &in);
 iterator insert(iterator it, const T &t);
 bool remove(size_type i);
 size_type removeAll(const T &t);
 void clear();
 void reset();
 void clip() { if (size() * 2 < capacity() && size() > S) changeAllocated(size()); }
 
 // Member access functions
 iterator begin() { return begin_; }
 const_iterator begin() const { return begin_; }
 const_iterator constBegin() const { return begin_; }
 iterator end() { return end_; }
 const_iterator end() const { return end_; }
 const_iterator constEnd() const { return end_; }
 T &at(size_type i) { return begin_[i]; }
 const T &at(size_type i) const { return begin_[i]; }
 T &operator[](size_type i) { return at(i); }
 const T &operator[](size_type i) const { return at(i); }
 T value(int i, const T &t = T()) const { if (i < 0) return t; if (to<size_type>(i) >= size()) return t; return at(i); }
 T value(uint32 i, const T &t = T()) const { if (to<size_type>(i) >= size()) return t; return at(i); }
 T value(uint64 i, const T &t = T()) const { if (to<size_type>(i) >= size()) return t; return at(i); }
private:
 void checkAllocated(size_type target);
 void changeAllocated(size_type newSize);
 union { // Note: std::array<> used so you can see contents in debugger (which has been really irritating).
 T *start_; // Placed in this union so constructors don't get called on creation.
 std::array<T, S> arr_;
 char buffer[sizeof(T)*S];
 };
 T *begin_ = reinterpret_cast<T *>(buffer);
 T *end_ = begin_;
 T *capacity_ = begin_ + S;
};
 
template <class T>
class FArray<T, 0> : public std::vector<T> {
public:
 using std::vector<T>::vector;
};
 
 
 
// ---------------------------------------------------------------------------
// IMPLEMENTATIONS
// ---------------------------------------------------------------------------
 
template <typename T,uint64 S>
FArray<T,S>::FArray(size_type s,const T &t) {
 checkAllocated(s);
 end_ = begin_ + s;
 for (T *b = begin_; b < end_; ++b)
 new(b) T(t);
}
 
template <typename T,uint64 S>
FArray<T,S>::FArray(std::initializer_list<T> l) {
 for (auto it = l.begin(); it != l.end(); ++it)
 push_back(*it);
}
 
template <typename T,uint64 S>
const FArray<T, S> &FArray<T,S>::operator=(const FArray<T, S> &f) {
 return operator=<S>(f);
}
 
template <typename T,uint64 S>
template <uint64 S2>
bool FArray<T,S>::operator==(const FArray<T,S2> &f) const {
 if (size()!=f.size()) return false;
 for (uint64 i=0;i<size();++i) {
 if (operator[](i)!=f[i])
 return false;
 }
 return true;
}
 
template <typename T,uint64 S>
template <uint64 S2>
const FArray<T, S> &FArray<T,S>::operator=(const FArray<T, S2> &f) {
 clear();
 checkAllocated(f.size());
 end_ = begin_ + f.size();
 T *bl = begin_;
 for (auto br = f.begin(); bl < end(); ++bl, ++br)
 new(bl) T(*br);
 return *this;
}
 
template <typename T,uint64 S>
typename FArray<T,S>::size_type FArray<T,S>::find(const T &t) const {
 for (size_type i = 0; i < size(); ++i) {
 if (at(i) == t) return i;
 }
 return limits<size_type>::max();
}
 
template <typename T,uint64 S>
T *FArray<T,S>::emplace_n_back(uint64 n) {
 checkAllocated(size() + n);
 T *ret = end_;
 end_ += n;
 return ret;
}
 
template <typename T,uint64 S>
void FArray<T,S>::resize(size_type i, const T &t) {
 if (size() == i) return;
 if (size() > i) {
 T *e = end_;
 end_ = begin_ + i;
 for (T *p = e - 1; p >= end_; --p)
 p->~T();
 return;
 }
 size_type s = size();
 checkAllocated(i);
 end_ = begin_ + i;
 for (T *p = begin_ + s; p < end_; ++p)
 new(p) T(t);
}
 
template <typename T,uint64 S>
typename FArray<T,S>::iterator FArray<T,S>::insert(size_type i, const T &t) {
 i = std::min(size(), i);
 if (i + 1 > size()) push_back(t);
 else {
 push_back(back());
 for (iterator p = end_ - 2; p > begin_ + i; --p)
 *p = *(p - 1);
 *(begin_ + i) = t;
 }
 return begin_ + i;
}
 
template <typename T,uint64 S>
void FArray<T,S>::put(size_type i, const T &t) {
 if (size() <= i) {
 resize(i);
 push_back(t);
 } else
 at(i) = t;
}
 
template <typename T,uint64 S>
template <class C>
void FArray<T,S>::append(const C &in) {
 for (auto i = in.begin(); i != in.end(); ++i)
 push_back(*i);
}
 
template <typename T,uint64 S>
typename FArray<T,S>::iterator FArray<T,S>::insert(iterator it, const T &t) {
 size_type i = it - begin_;
 i = std::min(size(), i);
 if (i + 1 > size()) push_back(t);
 else {
 push_back(back());
 for (iterator p = end_ - 2; p > begin_ + i; --p)
 *p = *(p - 1);
 *(begin_ + i) = t;
 }
 return begin_ + i;
}
 
template <typename T,uint64 S>
bool FArray<T,S>::remove(size_type i) {
 if (i >= size()) return false;
 for (iterator it = begin_ + i; it + 1 < end_; ++it)
 *it = *(it + 1);
 pop_back();
 return true;
}
 
template <typename T,uint64 S>
typename FArray<T,S>::size_type FArray<T,S>::removeAll(const T &t) {
 size_type ret = 0;
 for (size_type i = 0; i < size();) {
 if (t == at(i)) {
 remove(i);
 ++ret;
 } else
 ++i;
 }
 return ret;
}
 
template <typename T,uint64 S>
void FArray<T,S>::clear() {
 // if type T is not plain old data, call the destructor for each array element;
 if (!std::is_trivially_copyable<T>::value)
 for (T *b = begin_; b < end_; ++b)
 b->~T();
 end_ = begin_;
}
 
template <typename T,uint64 S>
void FArray<T,S>::reset() {
 clear();
 if (begin_ != reinterpret_cast<T *>(arr_.data()))
 ::free(begin_);
 end_ = begin_ = reinterpret_cast<T *>(arr_.data());
 capacity_ = begin_ + S;
}
 
template <typename T,uint64 S>
void FArray<T,S>::checkAllocated(size_type target) {
 static constexpr size_type max_increase = 1024*1000;
 if (begin_+target <= capacity_) return;
 size_type newsize = std::max<size_type>(capacity(), 4) * 2;
 while (newsize < target)
 newsize += to<size_type>(std::min(max_increase, newsize));
 changeAllocated(newsize);
}
 
template <typename T,uint64 S>
void FArray<T,S>::changeAllocated(size_type newSize) {
 size_type old_size = size();
 assert(old_size <= newSize);
 T *newBegin = reinterpret_cast<T *>(arr_.data());
 if (newSize > S)
#ifdef _DEBUG
 newBegin = reinterpret_cast<T *>(itasca::memory::imalloc(newSize * sizeof(T), __FILE__, __LINE__));
#else
 newBegin = reinterpret_cast<T *>(std::malloc(newSize * sizeof(T)));
#endif
 T *tl = newBegin;
 for (T *tr = begin_; tr < end_; ++tl, ++tr) {
 new(tl) T(std::move(*tr));
 tr->~T();
 }
 if (begin_ != reinterpret_cast<T *>(arr_.data()))
 std::free(begin_);
 begin_ = newBegin;
 end_ = begin_ + old_size;
 capacity_ = begin_ + newSize;
}
// EoF