mirror of
https://github.com/zhenyan121/Cubed.git
synced 2026-08-09 02:07:04 +08:00
435 lines
14 KiB
C++
435 lines
14 KiB
C++
#ifndef ENTT_CONTAINER_TABLE_HPP
|
|
#define ENTT_CONTAINER_TABLE_HPP
|
|
|
|
#include "../config/config.h"
|
|
#include "../core/iterator.hpp"
|
|
#include "../stl/concepts.hpp"
|
|
#include "../stl/cstddef.hpp"
|
|
#include "../stl/iterator.hpp"
|
|
#include "../stl/tuple.hpp"
|
|
#include "../stl/utility.hpp"
|
|
#include "fwd.hpp"
|
|
|
|
namespace entt {
|
|
|
|
/*! @cond ENTT_INTERNAL */
|
|
namespace internal {
|
|
|
|
template<typename... It>
|
|
class table_iterator {
|
|
template<typename...>
|
|
friend class table_iterator;
|
|
|
|
public:
|
|
using value_type = decltype(stl::forward_as_tuple(*stl::declval<It>()...));
|
|
using pointer = input_iterator_pointer<value_type>;
|
|
using reference = value_type;
|
|
using difference_type = stl::ptrdiff_t;
|
|
using iterator_category = stl::input_iterator_tag;
|
|
using iterator_concept = stl::random_access_iterator_tag;
|
|
|
|
constexpr table_iterator() noexcept
|
|
: it{} {}
|
|
|
|
constexpr table_iterator(It... from) noexcept
|
|
: it{from...} {}
|
|
|
|
template<typename... Other>
|
|
requires (stl::constructible_from<It, Other> && ...)
|
|
constexpr table_iterator(const table_iterator<Other...> &other) noexcept
|
|
: table_iterator{stl::get<Other>(other.it)...} {}
|
|
|
|
constexpr table_iterator &operator++() noexcept {
|
|
return (++stl::get<It>(it), ...), *this;
|
|
}
|
|
|
|
constexpr table_iterator operator++(int) noexcept {
|
|
const table_iterator orig = *this;
|
|
return ++(*this), orig;
|
|
}
|
|
|
|
constexpr table_iterator &operator--() noexcept {
|
|
return (--stl::get<It>(it), ...), *this;
|
|
}
|
|
|
|
constexpr table_iterator operator--(int) noexcept {
|
|
const table_iterator orig = *this;
|
|
return operator--(), orig;
|
|
}
|
|
|
|
constexpr table_iterator &operator+=(const difference_type value) noexcept {
|
|
return ((stl::get<It>(it) += value), ...), *this;
|
|
}
|
|
|
|
constexpr table_iterator operator+(const difference_type value) const noexcept {
|
|
table_iterator copy = *this;
|
|
return (copy += value);
|
|
}
|
|
|
|
constexpr table_iterator &operator-=(const difference_type value) noexcept {
|
|
return (*this += -value);
|
|
}
|
|
|
|
constexpr table_iterator operator-(const difference_type value) const noexcept {
|
|
return (*this + -value);
|
|
}
|
|
|
|
[[nodiscard]] constexpr reference operator[](const difference_type value) const noexcept {
|
|
return stl::forward_as_tuple(stl::get<It>(it)[value]...);
|
|
}
|
|
|
|
[[nodiscard]] constexpr pointer operator->() const noexcept {
|
|
return {operator[](0)};
|
|
}
|
|
|
|
[[nodiscard]] constexpr reference operator*() const noexcept {
|
|
return operator[](0);
|
|
}
|
|
|
|
template<typename... Other>
|
|
[[nodiscard]] constexpr stl::ptrdiff_t operator-(const table_iterator<Other...> &other) const noexcept {
|
|
return stl::get<0>(it) - stl::get<0>(other.it);
|
|
}
|
|
|
|
template<typename... Other>
|
|
[[nodiscard]] constexpr bool operator==(const table_iterator<Other...> &other) const noexcept {
|
|
return stl::get<0>(it) == stl::get<0>(other.it);
|
|
}
|
|
|
|
template<typename... Other>
|
|
[[nodiscard]] constexpr auto operator<=>(const table_iterator<Other...> &other) const noexcept {
|
|
return stl::get<0>(it) <=> stl::get<0>(other.it);
|
|
}
|
|
|
|
private:
|
|
stl::tuple<It...> it;
|
|
};
|
|
|
|
} // namespace internal
|
|
/*! @endcond */
|
|
|
|
/**
|
|
* @brief Basic table implementation.
|
|
*
|
|
* Internal data structures arrange elements to maximize performance. There are
|
|
* no guarantees that objects are returned in the insertion order when iterate
|
|
* a table. Do not make assumption on the order in any case.
|
|
*
|
|
* @tparam Container Sequence container row types.
|
|
*/
|
|
template<typename... Container>
|
|
class basic_table {
|
|
using container_type = stl::tuple<Container...>;
|
|
|
|
public:
|
|
/*! @brief Unsigned integer type. */
|
|
using size_type = stl::size_t;
|
|
/*! @brief Signed integer type. */
|
|
using difference_type = stl::ptrdiff_t;
|
|
/*! @brief Input iterator type. */
|
|
using iterator = internal::table_iterator<typename Container::iterator...>;
|
|
/*! @brief Constant input iterator type. */
|
|
using const_iterator = internal::table_iterator<typename Container::const_iterator...>;
|
|
/*! @brief Reverse iterator type. */
|
|
using reverse_iterator = internal::table_iterator<typename Container::reverse_iterator...>;
|
|
/*! @brief Constant reverse iterator type. */
|
|
using const_reverse_iterator = internal::table_iterator<typename Container::const_reverse_iterator...>;
|
|
|
|
/*! @brief Default constructor. */
|
|
basic_table()
|
|
: payload{} {
|
|
}
|
|
|
|
/**
|
|
* @brief Copy constructs the underlying containers.
|
|
* @param container The containers to copy from.
|
|
*/
|
|
explicit basic_table(const Container &...container) noexcept
|
|
: payload{container...} {
|
|
ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
|
|
}
|
|
|
|
/**
|
|
* @brief Move constructs the underlying containers.
|
|
* @param container The containers to move from.
|
|
*/
|
|
explicit basic_table(Container &&...container) noexcept
|
|
: payload{stl::move(container)...} {
|
|
ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
|
|
}
|
|
|
|
/*! @brief Default copy constructor, deleted on purpose. */
|
|
basic_table(const basic_table &) = delete;
|
|
|
|
/**
|
|
* @brief Move constructor.
|
|
* @param other The instance to move from.
|
|
*/
|
|
basic_table(basic_table &&other) noexcept
|
|
: payload{stl::move(other.payload)} {}
|
|
|
|
/**
|
|
* @brief Constructs the underlying containers using a given allocator.
|
|
* @param allocator A valid allocator.
|
|
*/
|
|
explicit basic_table(const auto &allocator)
|
|
: payload{Container{allocator}...} {}
|
|
|
|
/**
|
|
* @brief Copy constructs the underlying containers using a given allocator.
|
|
* @tparam Allocator Type of allocator.
|
|
* @param container The containers to copy from.
|
|
* @param allocator A valid allocator.
|
|
*/
|
|
template<class Allocator>
|
|
basic_table(const Container &...container, const Allocator &allocator) noexcept
|
|
: payload{Container{container, allocator}...} {
|
|
ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
|
|
}
|
|
|
|
/**
|
|
* @brief Move constructs the underlying containers using a given allocator.
|
|
* @tparam Allocator Type of allocator.
|
|
* @param container The containers to move from.
|
|
* @param allocator A valid allocator.
|
|
*/
|
|
template<class Allocator>
|
|
basic_table(Container &&...container, const Allocator &allocator) noexcept
|
|
: payload{Container{stl::move(container), allocator}...} {
|
|
ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
|
|
}
|
|
|
|
/**
|
|
* @brief Allocator-extended move constructor.
|
|
* @tparam Allocator Type of allocator.
|
|
* @param other The instance to move from.
|
|
* @param allocator The allocator to use.
|
|
*/
|
|
template<class Allocator>
|
|
basic_table(basic_table &&other, const Allocator &allocator)
|
|
: payload{Container{stl::move(stl::get<Container>(other.payload)), allocator}...} {}
|
|
|
|
/*! @brief Default destructor. */
|
|
~basic_table() = default;
|
|
|
|
/**
|
|
* @brief Default copy assignment operator, deleted on purpose.
|
|
* @return This container.
|
|
*/
|
|
basic_table &operator=(const basic_table &) = delete;
|
|
|
|
/**
|
|
* @brief Move assignment operator.
|
|
* @param other The instance to move from.
|
|
* @return This container.
|
|
*/
|
|
basic_table &operator=(basic_table &&other) noexcept {
|
|
swap(other);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* @brief Exchanges the contents with those of a given table.
|
|
* @param other Table to exchange the content with.
|
|
*/
|
|
void swap(basic_table &other) noexcept {
|
|
using stl::swap;
|
|
swap(payload, other.payload);
|
|
}
|
|
|
|
/**
|
|
* @brief Increases the capacity of a table.
|
|
*
|
|
* If the new capacity is greater than the current capacity, new storage is
|
|
* allocated, otherwise the method does nothing.
|
|
*
|
|
* @param cap Desired capacity.
|
|
*/
|
|
void reserve(const size_type cap) {
|
|
(stl::get<Container>(payload).reserve(cap), ...);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the number of rows that a table has currently allocated
|
|
* space for.
|
|
* @return Capacity of the table.
|
|
*/
|
|
[[nodiscard]] size_type capacity() const noexcept {
|
|
return stl::get<0>(payload).capacity();
|
|
}
|
|
|
|
/*! @brief Requests the removal of unused capacity. */
|
|
void shrink_to_fit() {
|
|
(stl::get<Container>(payload).shrink_to_fit(), ...);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the number of rows in a table.
|
|
* @return Number of rows.
|
|
*/
|
|
[[nodiscard]] size_type size() const noexcept {
|
|
return stl::get<0>(payload).size();
|
|
}
|
|
|
|
/**
|
|
* @brief Checks whether a table is empty.
|
|
* @return True if the table is empty, false otherwise.
|
|
*/
|
|
[[nodiscard]] bool empty() const noexcept {
|
|
return stl::get<0>(payload).empty();
|
|
}
|
|
|
|
/**
|
|
* @brief Returns an iterator to the beginning.
|
|
*
|
|
* If the table is empty, the returned iterator will be equal to `end()`.
|
|
*
|
|
* @return An iterator to the first row of the table.
|
|
*/
|
|
[[nodiscard]] const_iterator cbegin() const noexcept {
|
|
return {stl::get<Container>(payload).cbegin()...};
|
|
}
|
|
|
|
/*! @copydoc cbegin */
|
|
[[nodiscard]] const_iterator begin() const noexcept {
|
|
return cbegin();
|
|
}
|
|
|
|
/*! @copydoc begin */
|
|
[[nodiscard]] iterator begin() noexcept {
|
|
return {stl::get<Container>(payload).begin()...};
|
|
}
|
|
|
|
/**
|
|
* @brief Returns an iterator to the end.
|
|
* @return An iterator to the element following the last row of the table.
|
|
*/
|
|
[[nodiscard]] const_iterator cend() const noexcept {
|
|
return {stl::get<Container>(payload).cend()...};
|
|
}
|
|
|
|
/*! @copydoc cend */
|
|
[[nodiscard]] const_iterator end() const noexcept {
|
|
return cend();
|
|
}
|
|
|
|
/*! @copydoc end */
|
|
[[nodiscard]] iterator end() noexcept {
|
|
return {stl::get<Container>(payload).end()...};
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a reverse iterator to the beginning.
|
|
*
|
|
* If the table is empty, the returned iterator will be equal to `rend()`.
|
|
*
|
|
* @return An iterator to the first row of the reversed table.
|
|
*/
|
|
[[nodiscard]] const_reverse_iterator crbegin() const noexcept {
|
|
return {stl::get<Container>(payload).crbegin()...};
|
|
}
|
|
|
|
/*! @copydoc crbegin */
|
|
[[nodiscard]] const_reverse_iterator rbegin() const noexcept {
|
|
return crbegin();
|
|
}
|
|
|
|
/*! @copydoc rbegin */
|
|
[[nodiscard]] reverse_iterator rbegin() noexcept {
|
|
return {stl::get<Container>(payload).rbegin()...};
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a reverse iterator to the end.
|
|
* @return An iterator to the element following the last row of the reversed
|
|
* table.
|
|
*/
|
|
[[nodiscard]] const_reverse_iterator crend() const noexcept {
|
|
return {stl::get<Container>(payload).crend()...};
|
|
}
|
|
|
|
/*! @copydoc crend */
|
|
[[nodiscard]] const_reverse_iterator rend() const noexcept {
|
|
return crend();
|
|
}
|
|
|
|
/*! @copydoc rend */
|
|
[[nodiscard]] reverse_iterator rend() noexcept {
|
|
return {stl::get<Container>(payload).rend()...};
|
|
}
|
|
|
|
/**
|
|
* @brief Appends a row to the end of a table.
|
|
* @tparam Args Types of arguments to use to construct the row data.
|
|
* @param args Parameters to use to construct the row data.
|
|
* @return A reference to the newly created row data.
|
|
*/
|
|
template<typename... Args>
|
|
stl::tuple<typename Container::value_type &...> emplace(Args &&...args) {
|
|
if constexpr(sizeof...(Args) == 0u) {
|
|
return stl::forward_as_tuple(stl::get<Container>(payload).emplace_back()...);
|
|
} else {
|
|
return stl::forward_as_tuple(stl::get<Container>(payload).emplace_back(stl::forward<Args>(args))...);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Removes a row from a table.
|
|
* @param pos An iterator to the row to remove.
|
|
* @return An iterator following the removed row.
|
|
*/
|
|
iterator erase(const_iterator pos) {
|
|
const auto diff = pos - begin();
|
|
return {stl::get<Container>(payload).erase(stl::get<Container>(payload).begin() + diff)...};
|
|
}
|
|
|
|
/**
|
|
* @brief Removes a row from a table.
|
|
* @param pos Index of the row to remove.
|
|
*/
|
|
void erase(const size_type pos) {
|
|
ENTT_ASSERT(pos < size(), "Index out of bounds");
|
|
erase(begin() + static_cast<difference_type>(pos));
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the row data at specified location.
|
|
* @param pos The row for which to return the data.
|
|
* @return The row data at specified location.
|
|
*/
|
|
[[nodiscard]] stl::tuple<const typename Container::value_type &...> operator[](const size_type pos) const {
|
|
ENTT_ASSERT(pos < size(), "Index out of bounds");
|
|
return stl::forward_as_tuple(stl::get<Container>(payload)[pos]...);
|
|
}
|
|
|
|
/*! @copydoc operator[] */
|
|
[[nodiscard]] stl::tuple<typename Container::value_type &...> operator[](const size_type pos) {
|
|
ENTT_ASSERT(pos < size(), "Index out of bounds");
|
|
return stl::forward_as_tuple(stl::get<Container>(payload)[pos]...);
|
|
}
|
|
|
|
/*! @brief Clears a table. */
|
|
void clear() {
|
|
(stl::get<Container>(payload).clear(), ...);
|
|
}
|
|
|
|
private:
|
|
container_type payload;
|
|
};
|
|
|
|
} // namespace entt
|
|
|
|
/*! @cond ENTT_INTERNAL */
|
|
#include <utility>
|
|
|
|
namespace std {
|
|
|
|
template<typename... Container, typename Allocator>
|
|
struct uses_allocator<entt::basic_table<Container...>, Allocator>
|
|
: entt::stl::bool_constant<(entt::stl::uses_allocator_v<Container, Allocator> && ...)> {};
|
|
|
|
} // namespace std
|
|
/*! @endcond */
|
|
|
|
#endif
|