container.hpp

#ifndef ENTT_META_CONTAINER_HPP
#define ENTT_META_CONTAINER_HPP
 
#include <array>
#include <map>
#include <set>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "../container/dense_map.hpp"
#include "../container/dense_set.hpp"
#include "meta.hpp"
#include "type_traits.hpp"
 
namespace entt {
 
namespace internal {
 
template<typename, typename = void>
struct is_dynamic_sequence_container: std::false_type {};
 
template<typename Type>
struct is_dynamic_sequence_container<Type, std::void_t<decltype(&Type::reserve)>>: std::true_type {};
 
template<typename, typename = void>
struct is_key_only_meta_associative_container: std::true_type {};
 
template<typename Type>
struct is_key_only_meta_associative_container<Type, std::void_t<typename Type::mapped_type>>: std::false_type {};
 
template<typename Type>
struct basic_meta_sequence_container_traits {
    using iterator = meta_sequence_container::iterator;
    using size_type = std::size_t;
 
    [[nodiscard]] static size_type size(const any &container) ENTT_NOEXCEPT {
        return any_cast<const Type &>(container).size();
    }
 
    [[nodiscard]] static bool resize([[maybe_unused]] any &container, [[maybe_unused]] size_type sz) {
        if constexpr(is_dynamic_sequence_container<Type>::value) {
            if(auto *const cont = any_cast<Type>(&container); cont) {
                cont->resize(sz);
                return true;
            }
        }
 
        return false;
    }
 
    [[nodiscard]] static iterator iter(any &container, const bool as_end) {
        using std::begin;
 
        if(auto *const cont = any_cast<Type>(&container); cont) {
            return iterator{begin(*cont), static_cast<typename iterator::difference_type>(as_end * cont->size())};
        }
 
        const Type &as_const = any_cast<const Type &>(container);
        return iterator{begin(as_const), static_cast<typename iterator::difference_type>(as_end * as_const.size())};
    }
 
    [[nodiscard]] static iterator insert([[maybe_unused]] any &container, [[maybe_unused]] const std::ptrdiff_t offset, [[maybe_unused]] meta_any &value) {
        if constexpr(is_dynamic_sequence_container<Type>::value) {
            if(auto *const cont = any_cast<Type>(&container); cont) {
                // this abomination is necessary because only on macos value_type and const_reference are different types for std::vector<bool>
                if(value.allow_cast<typename Type::const_reference>() || value.allow_cast<typename Type::value_type>()) {
                    using std::begin;
                    const auto *element = value.try_cast<std::remove_reference_t<typename Type::const_reference>>();
                    const auto curr = cont->insert(begin(*cont) + offset, element ? *element : value.cast<typename Type::value_type>());
                    return iterator{curr, curr - begin(*cont)};
                }
            }
        }
 
        return {};
    }
 
    [[nodiscard]] static iterator erase([[maybe_unused]] any &container, [[maybe_unused]] const std::ptrdiff_t offset) {
        if constexpr(is_dynamic_sequence_container<Type>::value) {
            if(auto *const cont = any_cast<Type>(&container); cont) {
                using std::begin;
                const auto curr = cont->erase(begin(*cont) + offset);
                return iterator{curr, curr - begin(*cont)};
            }
        }
 
        return {};
    }
};
 
template<typename Type>
struct basic_meta_associative_container_traits {
    using iterator = meta_associative_container::iterator;
    using size_type = std::size_t;
 
    static constexpr auto key_only = is_key_only_meta_associative_container<Type>::value;
 
    [[nodiscard]] static size_type size(const any &container) ENTT_NOEXCEPT {
        return any_cast<const Type &>(container).size();
    }
 
    [[nodiscard]] static bool clear(any &container) {
        if(auto *const cont = any_cast<Type>(&container); cont) {
            cont->clear();
            return true;
        }
 
        return false;
    }
 
    [[nodiscard]] static iterator iter(any &container, const bool as_end) {
        using std::begin;
        using std::end;
 
        if(auto *const cont = any_cast<Type>(&container); cont) {
            return iterator{std::integral_constant<bool, key_only>{}, as_end ? end(*cont) : begin(*cont)};
        }
 
        const auto &as_const = any_cast<const Type &>(container);
        return iterator{std::integral_constant<bool, key_only>{}, as_end ? end(as_const) : begin(as_const)};
    }
 
    [[nodiscard]] static bool insert(any &container, meta_any &key, [[maybe_unused]] meta_any &value) {
        auto *const cont = any_cast<Type>(&container);
 
        if constexpr(is_key_only_meta_associative_container<Type>::value) {
            return cont && key.allow_cast<const typename Type::key_type &>()
                   && cont->insert(key.cast<const typename Type::key_type &>()).second;
        } else {
            return cont && key.allow_cast<const typename Type::key_type &>() && value.allow_cast<const typename Type::mapped_type &>()
                   && cont->emplace(key.cast<const typename Type::key_type &>(), value.cast<const typename Type::mapped_type &>()).second;
        }
    }
 
    [[nodiscard]] static bool erase(any &container, meta_any &key) {
        auto *const cont = any_cast<Type>(&container);
        return cont && key.allow_cast<const typename Type::key_type &>()
               && (cont->erase(key.cast<const typename Type::key_type &>()) != cont->size());
    }
 
    [[nodiscard]] static iterator find(any &container, meta_any &key) {
        if(key.allow_cast<const typename Type::key_type &>()) {
            if(auto *const cont = any_cast<Type>(&container); cont) {
                return iterator{std::integral_constant<bool, key_only>{}, cont->find(key.cast<const typename Type::key_type &>())};
            }
 
            return iterator{std::integral_constant<bool, key_only>{}, any_cast<const Type &>(container).find(key.cast<const typename Type::key_type &>())};
        }
 
        return {};
    }
};
 
} // namespace internal
 
template<typename Type, typename... Args>
struct meta_sequence_container_traits<std::vector<Type, Args...>>
    : internal::basic_meta_sequence_container_traits<std::vector<Type, Args...>> {};
 
template<typename Type, auto N>
struct meta_sequence_container_traits<std::array<Type, N>>
    : internal::basic_meta_sequence_container_traits<std::array<Type, N>> {};
 
template<typename Key, typename Value, typename... Args>
struct meta_associative_container_traits<std::map<Key, Value, Args...>>
    : internal::basic_meta_associative_container_traits<std::map<Key, Value, Args...>> {};
 
template<typename Key, typename Value, typename... Args>
struct meta_associative_container_traits<std::unordered_map<Key, Value, Args...>>
    : internal::basic_meta_associative_container_traits<std::unordered_map<Key, Value, Args...>> {};
 
template<typename Key, typename... Args>
struct meta_associative_container_traits<std::set<Key, Args...>>
    : internal::basic_meta_associative_container_traits<std::set<Key, Args...>> {};
 
template<typename Key, typename... Args>
struct meta_associative_container_traits<std::unordered_set<Key, Args...>>
    : internal::basic_meta_associative_container_traits<std::unordered_set<Key, Args...>> {};
 
template<typename Key, typename Type, typename... Args>
struct meta_associative_container_traits<dense_map<Key, Type, Args...>>
    : internal::basic_meta_associative_container_traits<dense_map<Key, Type, Args...>> {};
 
template<typename Type, typename... Args>
struct meta_associative_container_traits<dense_set<Type, Args...>>
    : internal::basic_meta_associative_container_traits<dense_set<Type, Args...>> {};
 
} // namespace entt
 
#endif