container.hpp

#ifndef ENTT_META_CONTAINER_HPP
#define ENTT_META_CONTAINER_HPP
 
 
#include <array>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include "../config/config.h"
#include "type_traits.hpp"
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename Container, template<typename> class... Trait>
struct container_traits: public Trait<Container>... {};
 
 
template<typename Container>
struct basic_container {
    using iterator = typename Container::iterator;
    using size_type = typename Container::size_type;
    using value_type = typename Container::value_type;
 
    [[nodiscard]] static size_type size(const Container &cont) ENTT_NOEXCEPT {
        return cont.size();
    }
 
    [[nodiscard]] static iterator begin(Container &cont) {
        return cont.begin();
    }
 
    [[nodiscard]] static iterator end(Container &cont) {
        return cont.end();
    }
};
 
 
template<typename Container>
struct basic_associative_container {
    using key_type = typename Container::key_type;
 
    [[nodiscard]] static typename Container::iterator find(Container &cont, const key_type &key) {
        return cont.find(key);
    }
};
 
 
template<typename Container>
struct basic_dynamic_container {
    [[nodiscard]] static bool clear(Container &cont) {
        return cont.clear(), true;
    }
};
 
 
template<typename Container>
struct basic_dynamic_associative_container {
    [[nodiscard]] static bool erase(Container &cont, const typename Container::key_type &key) {
        const auto sz = cont.size();
        return cont.erase(key) != sz;
    }
};
 
 
template<typename Container>
struct basic_sequence_container {
    [[nodiscard]] static typename Container::value_type & get(Container &cont, typename Container::size_type pos) {
        return cont[pos];
    }
};
 
 
template<typename Container>
struct dynamic_associative_key_only_container {
    [[nodiscard]] static bool insert(Container &cont, const typename Container::key_type &key) {
        return cont.insert(key).second;
    }
};
 
 
template<typename Container>
struct dynamic_associative_key_value_container {
    [[nodiscard]] static bool insert(Container &cont, const typename Container::key_type &key, const typename Container::mapped_type &value) {
        return cont.insert(std::make_pair(key, value)).second;
    }
};
 
 
template<typename Container>
struct dynamic_sequence_container {
    [[nodiscard]] static bool resize(Container &cont, typename Container::size_type sz) {
        return (cont.resize(sz), true);
    }
 
    [[nodiscard]] static std::pair<typename Container::iterator, bool> insert(Container &cont, typename Container::iterator it, const typename Container::value_type &value) {
        return { cont.insert(it, value), true };
    }
 
    [[nodiscard]] static std::pair<typename Container::iterator, bool> erase(Container &cont, typename Container::iterator it) {
        return { cont.erase(it), true };
    }
};
 
 
template<typename Container>
struct fixed_sequence_container {
    [[nodiscard]] static bool resize(const Container &, typename Container::size_type) {
        return false;
    }
 
    [[nodiscard]] static bool clear(const Container &) {
        return false;
    }
 
    [[nodiscard]] static std::pair<typename Container::iterator, bool> insert(const Container &, typename Container::iterator, const typename Container::value_type &) {
        return { {}, false };
    }
 
    [[nodiscard]] static std::pair<typename Container::iterator, bool> erase(const Container &, typename Container::iterator) {
        return { {}, false };
    }
};
 
 
}
 
 
template<typename Type, typename... Args>
struct meta_sequence_container_traits<std::vector<Type, Args...>>
        : internal::container_traits<
            std::vector<Type, Args...>,
            internal::basic_container,
            internal::basic_dynamic_container,
            internal::basic_sequence_container,
            internal::dynamic_sequence_container
        >
{};
 
 
template<typename Type, auto N>
struct meta_sequence_container_traits<std::array<Type, N>>
        : internal::container_traits<
            std::array<Type, N>,
            internal::basic_container,
            internal::basic_sequence_container,
            internal::fixed_sequence_container
        >
{};
 
 
template<typename Key, typename Value, typename... Args>
struct meta_associative_container_traits<std::map<Key, Value, Args...>>
        : internal::container_traits<
            std::map<Key, Value, Args...>,
            internal::basic_container,
            internal::basic_associative_container,
            internal::basic_dynamic_container,
            internal::basic_dynamic_associative_container,
            internal::dynamic_associative_key_value_container
        >
{
    using mapped_type = typename std::map<Key, Value, Args...>::mapped_type;
};
 
 
template<typename Key, typename Value, typename... Args>
struct meta_associative_container_traits<std::unordered_map<Key, Value, Args...>>
        : internal::container_traits<
            std::unordered_map<Key, Value, Args...>,
            internal::basic_container,
            internal::basic_associative_container,
            internal::basic_dynamic_container,
            internal::basic_dynamic_associative_container,
            internal::dynamic_associative_key_value_container
        >
{
    using mapped_type = typename std::unordered_map<Key, Value, Args...>::mapped_type;
};
 
 
template<typename Key, typename... Args>
struct meta_associative_container_traits<std::set<Key, Args...>>
        : internal::container_traits<
            std::set<Key, Args...>,
            internal::basic_container,
            internal::basic_associative_container,
            internal::basic_dynamic_container,
            internal::basic_dynamic_associative_container,
            internal::dynamic_associative_key_only_container
        >
{};
 
 
template<typename Key, typename... Args>
struct meta_associative_container_traits<std::unordered_set<Key, Args...>>
        : internal::container_traits<
            std::unordered_set<Key, Args...>,
            internal::basic_container,
            internal::basic_associative_container,
            internal::basic_dynamic_container,
            internal::basic_dynamic_associative_container,
            internal::dynamic_associative_key_only_container
        >
{};
 
 
}
 
 
#endif