138 lines
3.4 KiB
C++
Executable File
138 lines
3.4 KiB
C++
Executable File
// License: Modified MIT (NON-AI)
|
|
// See the LICENSE file in the root directory for license information.
|
|
// Copyright 2025 Timothy Prepscius
|
|
|
|
#pragma once
|
|
|
|
#include "InPlaceArray.h"
|
|
#include "Array.h"
|
|
|
|
#include <cstddef>
|
|
#include <memory>
|
|
#include <array>
|
|
|
|
#include "../types/Types.h"
|
|
|
|
namespace tjp {
|
|
namespace core {
|
|
|
|
template<typename T, size_t N>
|
|
class InPlaceArray
|
|
{
|
|
public:
|
|
static constexpr size_t MaxLength = N;
|
|
|
|
private:
|
|
using Array = std::array<T, N>;
|
|
using Block = char;
|
|
using Size = u32;
|
|
|
|
union Static {
|
|
Block block;
|
|
Array array;
|
|
|
|
Static() : block(0) {}
|
|
~Static () {}
|
|
} ;
|
|
|
|
Static v;
|
|
Size length = 0;
|
|
|
|
typedef std::allocator<T> Allocator;
|
|
Allocator allocator;
|
|
|
|
public:
|
|
using value_type = typename Array::value_type;
|
|
using iterator = typename Array::iterator;
|
|
using const_iterator = typename Array::const_iterator;
|
|
using pointer = typename Array::pointer;
|
|
using reference = typename Array::reference;
|
|
using const_reference = typename Array::const_reference;
|
|
|
|
inline auto data() { return v.array.data(); }
|
|
inline auto data() const { return v.array.data(); }
|
|
|
|
inline auto begin() { return v.array.begin(); }
|
|
inline auto end () { return v.array.begin() + length; }
|
|
|
|
inline auto begin() const { return v.array.begin(); }
|
|
inline auto end () const { return v.array.begin() + length; }
|
|
|
|
inline auto rbegin() { return v.array.rbegin() + (v.array.size() - length); }
|
|
inline auto rend () { return v.array.rend(); }
|
|
|
|
inline auto rbegin() const { return v.array.rbegin() + (v.array.size() - length); }
|
|
inline auto rend () const { return v.array.rend(); }
|
|
|
|
inline const_reference front () const { return v.array.front(); }
|
|
inline const_reference back () const { return *(v.array.data() + (length - 1)); }
|
|
inline reference front () { return v.array.front(); }
|
|
inline reference back () { return *(v.array.data() + (length - 1)); }
|
|
|
|
private:
|
|
template<typename ... Args>
|
|
void construct(T *t, Args&& ...args)
|
|
{
|
|
std::allocator_traits<Allocator>::construct(allocator, t, std::forward<Args>(args)...);
|
|
}
|
|
|
|
void destruct(T *t)
|
|
{
|
|
std::allocator_traits<Allocator>::destroy(allocator, t);
|
|
}
|
|
|
|
protected:
|
|
void shorten_block(size_t length_);
|
|
void shorten_items(size_t length_);
|
|
void shorten(size_t length_);
|
|
void append_block(const T *begin, const T *end);
|
|
void append_items(const T *begin, const T *end);
|
|
void emplace_items(T *begin, T *end);
|
|
|
|
public:
|
|
InPlaceArray ();
|
|
InPlaceArray(size_t length_, T t=T());
|
|
|
|
// InPlaceArray(InPlaceArray &&rhs);
|
|
|
|
// template<size_t N2>
|
|
InPlaceArray(const InPlaceArray<T, N> &rhs);
|
|
InPlaceArray(const std::initializer_list<T> &rhs);
|
|
InPlaceArray(const T *begin, const T *end);
|
|
InPlaceArray(const T *begin, size_t size);
|
|
|
|
// template<size_t N2>
|
|
InPlaceArray &operator =(const InPlaceArray<T, N> &rhs);
|
|
InPlaceArray &operator =(const Array &rhs);
|
|
~InPlaceArray ();
|
|
|
|
void resize(size_t length_, T t=T());
|
|
void append(const T *begin, const T *end);
|
|
void emplace(T *begin, T *end);
|
|
|
|
void push_back_();
|
|
void push_back (const T &element);
|
|
void push_back (T &&element);
|
|
void pop_back ();
|
|
|
|
template<typename ... Args>
|
|
T &emplace_back (Args&& ...args);
|
|
|
|
const T &at(size_t i) const;
|
|
T &at(size_t i);
|
|
|
|
const T &operator[] (size_t i) const;
|
|
T &operator[] (size_t i);
|
|
|
|
size_t size () const;
|
|
void clear ();
|
|
|
|
bool empty () const;
|
|
} ;
|
|
|
|
} // namespace utilities
|
|
} // namespace
|
|
|
|
#include "InPlaceArray.inl"
|
|
#include "InPlaceArray+iterator.inl"
|