flat_unordered_multimap.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_CONTAINER_FLAT_UNORDERED_MULTIMAP_HPP__
#define NEFORCE_CORE_CONTAINER_FLAT_UNORDERED_MULTIMAP_HPP__

 
#include "NeForce/core/container/flat_hashtable.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Key, typename T, typename HashFcn = hash<Key>, typename EqualKey = equal_to<Key>,
          typename Alloc = allocator<pair<Key, T>>>
class flat_unordered_multimap : public icollector<flat_unordered_multimap<Key, T, HashFcn, EqualKey, Alloc>> {
    static_assert(is_hash_v<HashFcn, Key>, "flat_unordered_multimap requires valid hash function.");
    static_assert(is_allocator_v<Alloc>, "Alloc type is not a standard allocator type.");
    static_assert(is_object_v<Key>, "flat_unordered_multimap only contains object types.");
 
private:
    using base_type = flat_hashtable<pair<Key, T>, Key, HashFcn, select1st<pair<Key, T>>, EqualKey,
                                     Alloc>; 
 
public:
    using key_type = typename base_type::key_type;   
    using mapped_type = T;                           
    using value_type = pair<Key, T>;                 
    using hasher = typename base_type::hasher;       
    using key_equal = typename base_type::key_equal; 
 
    using size_type = typename base_type::size_type;             
    using difference_type = typename base_type::difference_type; 
    using pointer = value_type*;                                 
    using const_pointer = const value_type*;                     
    using reference = value_type&;                               
    using const_reference = const value_type&;                   
    using iterator = typename base_type::iterator;               
    using const_iterator = typename base_type::const_iterator;   
    using allocator_type = typename base_type::allocator_type;   
 
private:
    base_type ht_; 
 
public:
    flat_unordered_multimap() = default;

    explicit flat_unordered_multimap(const size_type n) :
    ht_(n) {}

    flat_unordered_multimap(const size_type n, const hasher& hf) :
    ht_(n, hf) {}

    flat_unordered_multimap(const size_type n, const hasher& hf, const key_equal& eql) :
    ht_(n, hf, eql) {}

    flat_unordered_multimap(const flat_unordered_multimap& other) :
    ht_(other.ht_) {}

    flat_unordered_multimap& operator=(const flat_unordered_multimap& other) {
        ht_ = other.ht_;
        return *this;
    }

    flat_unordered_multimap(flat_unordered_multimap&& other) noexcept(is_nothrow_move_constructible_v<base_type>) :
    ht_(_NEFORCE move(other.ht_)) {}

    flat_unordered_multimap&
    operator=(flat_unordered_multimap&& other) noexcept(is_nothrow_move_assignable_v<base_type>) {
        ht_ = _NEFORCE move(other.ht_);
        return *this;
    }

    template <typename Iterator>
    flat_unordered_multimap(Iterator first, Iterator last) :
    ht_() {
        ht_.insert_equal(first, last);
    }

    template <typename Iterator>
    flat_unordered_multimap(Iterator first, Iterator last, const size_type n) :
    ht_(n) {
        ht_.insert_equal(first, last);
    }

    template <typename Iterator>
    flat_unordered_multimap(Iterator first, Iterator last, const size_type n, const hasher& hf) :
    ht_(n, hf) {
        ht_.insert_equal(first, last);
    }

    template <typename Iterator>
    flat_unordered_multimap(Iterator first, Iterator last, const size_type n, const hasher& hf, const key_equal& eql) :
    ht_(n, hf, eql) {
        ht_.insert_equal(first, last);
    }

    flat_unordered_multimap(std::initializer_list<value_type> ilist) :
    flat_unordered_multimap(ilist.begin(), ilist.end()) {}

    flat_unordered_multimap(std::initializer_list<value_type> ilist, const size_type n) :
    flat_unordered_multimap(ilist.begin(), ilist.end(), n) {}

    flat_unordered_multimap(std::initializer_list<value_type> ilist, const size_type n, const hasher& hf) :
    flat_unordered_multimap(ilist.begin(), ilist.end(), n, hf) {}

    flat_unordered_multimap(std::initializer_list<value_type> ilist, const size_type n, const hasher& hf,
                            const key_equal& eql) :
    flat_unordered_multimap(ilist.begin(), ilist.end(), n, hf, eql) {}

    NEFORCE_NODISCARD iterator begin() noexcept { return ht_.begin(); }

    NEFORCE_NODISCARD iterator end() noexcept { return ht_.end(); }

    NEFORCE_NODISCARD const_iterator begin() const noexcept { return ht_.begin(); }

    NEFORCE_NODISCARD const_iterator end() const noexcept { return ht_.end(); }

    NEFORCE_NODISCARD const_iterator cbegin() const noexcept { return ht_.cbegin(); }

    NEFORCE_NODISCARD const_iterator cend() const noexcept { return ht_.cend(); }

    NEFORCE_NODISCARD size_type size() const noexcept { return ht_.size(); }

    NEFORCE_NODISCARD size_type max_size() const noexcept { return ht_.max_size(); }

    NEFORCE_NODISCARD bool empty() const noexcept { return ht_.empty(); }

    NEFORCE_NODISCARD size_type capacity() const noexcept { return ht_.capacity(); }

    NEFORCE_NODISCARD size_type count(const key_type& key) const noexcept(noexcept(ht_.count(key))) {
        return ht_.count(key);
    }

    NEFORCE_NODISCARD bool contains(const key_type& key) const noexcept(noexcept(ht_.contains(key))) {
        return ht_.contains(key);
    }

    NEFORCE_NODISCARD hasher hash_function() const noexcept(noexcept(ht_.hash_function())) {
        return ht_.hash_function();
    }

    NEFORCE_NODISCARD key_equal key_eql() const noexcept(noexcept(ht_.key_eql())) { return ht_.key_eql(); }

    NEFORCE_NODISCARD float load_factor() const noexcept { return ht_.load_factor(); }

    NEFORCE_NODISCARD float max_load_factor() const noexcept { return ht_.max_load_factor(); }

    void max_load_factor(const float lf) noexcept { ht_.max_load_factor(lf); }

    void rehash(const size_type n) { ht_.rehash(n); }

    void reserve(const size_type n) { ht_.reserve(n); }

    template <typename... Args>
    iterator emplace(Args&&... args) {
        return ht_.emplace_equal(_NEFORCE forward<Args>(args)...);
    }

    iterator insert(const value_type& value) { return ht_.insert_equal(value); }

    iterator insert(value_type&& value) { return ht_.insert_equal(_NEFORCE move(value)); }

    template <typename Iterator>
    void insert(Iterator first, Iterator last) {
        ht_.insert_equal(first, last);
    }

    void insert(std::initializer_list<value_type> ilist) { ht_.insert_equal(ilist); }

    size_type erase(const key_type& key) noexcept { return ht_.erase(key); }

    iterator erase(const iterator position) noexcept { return ht_.erase(position); }

    iterator erase(const iterator first, const iterator last) noexcept { return ht_.erase(first, last); }

    const_iterator erase(const const_iterator position) noexcept { return ht_.erase(position); }

    const_iterator erase(const const_iterator first, const const_iterator last) noexcept {
        return ht_.erase(first, last);
    }

    void clear() noexcept { ht_.clear(); }

    NEFORCE_NODISCARD iterator find(const key_type& key) { return ht_.find(key); }

    NEFORCE_NODISCARD const_iterator find(const key_type& key) const { return ht_.find(key); }

    NEFORCE_NODISCARD pair<iterator, iterator> equal_range(const key_type& key) { return ht_.equal_range(key); }

    NEFORCE_NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& key) const {
        return ht_.equal_range(key);
    }

    void swap(flat_unordered_multimap& other) noexcept(is_nothrow_swappable_v<base_type>) { ht_.swap(other.ht_); }

    NEFORCE_NODISCARD bool equal_to(const flat_unordered_multimap& rhs) const noexcept(noexcept(ht_ == rhs.ht_)) {
        return ht_ == rhs.ht_;
    }

    NEFORCE_NODISCARD bool less_than(const flat_unordered_multimap& rhs) const noexcept(noexcept(ht_ < rhs.ht_)) {
        return ht_ < rhs.ht_;
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename Iterator, typename HashFcn = hash<iter_map_key_t<Iterator>>,
          typename Compare = equal_to<iter_map_key_t<Iterator>>, typename Alloc>
flat_unordered_multimap(Iterator, Iterator, HashFcn = HashFcn(), Compare = Compare(), Alloc = Alloc())
        -> flat_unordered_multimap<iter_map_key_t<Iterator>, iter_map_value_t<Iterator>, HashFcn, Compare, Alloc>;
 
template <typename Key, typename T, typename HashFcn = hash<Key>, typename Compare = equal_to<Key>,
          typename Alloc = allocator<pair<Key, T>>>
flat_unordered_multimap(std::initializer_list<pair<Key, T>>, HashFcn = HashFcn(), Compare = Compare(), Alloc = Alloc())
        -> flat_unordered_multimap<Key, T, HashFcn, Compare, Alloc>;
 
template <typename Iterator, typename Alloc>
flat_unordered_multimap(Iterator, Iterator, Alloc)
        -> flat_unordered_multimap<iter_map_key_t<Iterator>, iter_map_value_t<Iterator>, hash<iter_map_key_t<Iterator>>,
                                   equal_to<iter_map_key_t<Iterator>>, Alloc>;
 
template <typename Iterator, typename HashFcn, typename Alloc>
flat_unordered_multimap(Iterator, Iterator, HashFcn, Alloc)
        -> flat_unordered_multimap<iter_map_key_t<Iterator>, iter_map_value_t<Iterator>, HashFcn,
                                   equal_to<iter_map_key_t<Iterator>>, Alloc>;
 
template <typename Key, typename T, typename Alloc>
flat_unordered_multimap(std::initializer_list<pair<Key, T>>, Alloc)
        -> flat_unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Alloc>;
 
template <typename Key, typename T, typename HashFcn, typename Alloc>
flat_unordered_multimap(std::initializer_list<pair<Key, T>>, HashFcn, Alloc)
        -> flat_unordered_multimap<Key, T, HashFcn, equal_to<Key>, Alloc>;
#endif
 // Container
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_CONTAINER_FLAT_UNORDERED_MULTIMAP_HPP__