2021-01-08 10:11:28 +01:00
|
|
|
/*****************************************************************************
|
2022-10-01 09:42:14 +02:00
|
|
|
* Copyright (c) 2014-2022 OpenRCT2 developers
|
2021-01-08 10:11:28 +01:00
|
|
|
*
|
|
|
|
* For a complete list of all authors, please refer to contributors.md
|
|
|
|
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
|
|
|
|
*
|
|
|
|
* OpenRCT2 is licensed under the GNU General Public License version 3.
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "Guard.hpp"
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <array>
|
|
|
|
#include <utility>
|
|
|
|
|
|
|
|
template<typename T, size_t MAX> class FixedVector
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
using container = std::array<T, MAX>;
|
|
|
|
using iterator = typename container::iterator;
|
|
|
|
using const_iterator = typename container::const_iterator;
|
|
|
|
using reverse_iterator = typename container::reverse_iterator;
|
|
|
|
using const_reverse_iterator = typename container::const_reverse_iterator;
|
|
|
|
using value_type = typename container::value_type;
|
|
|
|
using reference_type = value_type&;
|
|
|
|
using const_reference_type = const value_type&;
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr iterator begin()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
if (_count == 0)
|
|
|
|
return _data.end();
|
|
|
|
|
|
|
|
return _data.begin();
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr iterator end()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
if (_count == 0)
|
|
|
|
return _data.end();
|
|
|
|
return begin() + _count;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr const_iterator cbegin() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
if (_count == 0)
|
|
|
|
return _data.cend();
|
|
|
|
|
|
|
|
return _data.cbegin();
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr const_iterator cend() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
if (_count == 0)
|
|
|
|
return _data.cend();
|
|
|
|
return cbegin() + _count;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr reverse_iterator rbegin()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
if (_count == 0)
|
|
|
|
return _data.rend();
|
|
|
|
return _data.rbegin() + (MAX - _count);
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr reverse_iterator rend()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data.rend();
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr const_reverse_iterator rbegin() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data.rbegin() + (MAX - _count);
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr const_reverse_iterator rend() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data.rend();
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr reference_type back()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data[_count - 1];
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr const_reference_type back() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data[_count - 1];
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr void push_back(const T& val)
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
Guard::Assert(_count < MAX);
|
|
|
|
_data[_count++] = val;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr void push_back(T&& val)
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
Guard::Assert(_count < MAX);
|
|
|
|
_data[_count++] = std::move(val);
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr iterator insert(iterator pos, const T& val)
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
// Make sure the end iterator is correct.
|
|
|
|
auto itCurEnd = end();
|
|
|
|
push_back(val);
|
|
|
|
|
|
|
|
// Shift all elements to the right
|
|
|
|
auto offset = pos - begin();
|
|
|
|
std::rotate(_data.begin(), pos, itCurEnd);
|
|
|
|
|
|
|
|
return _data.begin() + offset;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr iterator insert(iterator pos, T&& val)
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
// Make sure the end iterator is correct.
|
|
|
|
auto itCurEnd = end();
|
|
|
|
emplace_back(std::move(val));
|
|
|
|
|
|
|
|
// Shift all elements to the right
|
|
|
|
auto offset = pos - begin();
|
|
|
|
std::rotate(_data.begin() + offset, itCurEnd, end());
|
|
|
|
|
|
|
|
return _data.begin() + offset;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
template<typename... Args> constexpr reference_type emplace_back(Args&&... args)
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
Guard::Assert(_count < MAX);
|
|
|
|
reference_type res = _data[_count++];
|
|
|
|
::new (&res) T(std::forward<Args&&>(args)...);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr reference_type operator[](const size_t n)
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data[n];
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr const_reference_type operator[](const size_t n) const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data[n];
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr void pop_back()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
_count--;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr void clear()
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
_count = 0;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr size_t size() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _count;
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr size_t capacity() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _data.size();
|
|
|
|
}
|
|
|
|
|
2021-01-30 07:10:40 +01:00
|
|
|
constexpr bool empty() const
|
2021-01-08 10:11:28 +01:00
|
|
|
{
|
|
|
|
return _count == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
size_t _count = 0;
|
|
|
|
container _data;
|
|
|
|
};
|