multiset.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_CONTAINER_MULTISET_HPP__
#define NEFORCE_CORE_CONTAINER_MULTISET_HPP__

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


template <typename Key, typename Compare = less<Key>, typename Alloc = allocator<rb_tree_node<Key>>>
class multiset : icollector<multiset<Key, Compare, Alloc>> {
    static_assert(is_allocator_v<Alloc>, "Alloc type is not a standard allocator type.");
    static_assert(is_same_v<rb_tree_node<Key>, typename Alloc::value_type>, "allocator type mismatch.");
    static_assert(is_object_v<Key>, "multiset only contains object types.");
 
public:
    using key_type = Key;          
    using value_type = Key;        
    using key_compare = Compare;   
    using value_compare = Compare; 
 
private:
    using base_type = rb_tree<Key, Key, identity<Key>, Compare, Alloc>; 
 
public:
    using size_type = typename base_type::size_type;                           
    using difference_type = typename base_type::difference_type;               
    using pointer = typename base_type::pointer;                               
    using const_pointer = typename base_type::const_pointer;                   
    using reference = typename base_type::reference;                           
    using const_reference = typename base_type::const_reference;               
    using iterator = typename base_type::iterator;                             
    using const_iterator = typename base_type::const_iterator;                 
    using reverse_iterator = typename base_type::reverse_iterator;             
    using const_reverse_iterator = typename base_type::const_reverse_iterator; 
    using allocator_type = typename base_type::allocator_type;                 
 
private:
    base_type tree_; 
 
public:
    multiset() :
    tree_(Compare()) {}

    explicit multiset(const key_compare& comp) :
    tree_(comp) {}

    multiset(const multiset& other) :
    tree_(other.tree_) {}

    multiset& operator=(const multiset& other) {
        tree_ = other.tree_;
        return *this;
    }

    multiset(multiset&& other) noexcept(is_nothrow_move_constructible_v<base_type>) :
    tree_(_NEFORCE move(other.tree_)) {}

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

    template <typename Iterator>
    multiset(Iterator first, Iterator last) :
    tree_(Compare()) {
        tree_.insert_equal(first, last);
    }

    template <typename Iterator>
    multiset(Iterator first, Iterator last, const key_compare& comp) :
    tree_(comp) {
        tree_.insert_equal(first, last);
    }

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

    multiset(std::initializer_list<value_type> ilist, const key_compare& comp) :
    multiset(ilist.begin(), ilist.end(), comp) {}

    multiset& operator=(std::initializer_list<value_type> ilist) {
        clear();
        insert(ilist.begin(), ilist.end());
        return *this;
    }

    ~multiset() = default;

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

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

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

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

    NEFORCE_NODISCARD reverse_iterator rbegin() noexcept { return reverse_iterator(tree_.begin()); }

    NEFORCE_NODISCARD reverse_iterator rend() noexcept { return reverse_iterator(tree_.end()); }

    NEFORCE_NODISCARD const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(tree_.cbegin()); }

    NEFORCE_NODISCARD const_reverse_iterator crend() const noexcept { return const_reverse_iterator(tree_.cend()); }

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

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

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

    NEFORCE_NODISCARD key_compare key_comp() const noexcept { return tree_.key_comp(); }

    NEFORCE_NODISCARD value_compare value_comp() const noexcept { return value_compare(tree_.key_comp()); }

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

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

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

    template <typename... Args>
    iterator emplace_hint(iterator position, Args&&... args) {
        return tree_.emplace_equal_hint(position, _NEFORCE forward<Args>(args)...);
    }

    iterator insert(iterator position, const value_type& value) { return tree_.insert_equal(position, value); }

    iterator insert(iterator position, value_type&& value) {
        return tree_.insert_equal(position, _NEFORCE move(value));
    }

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

    void erase(iterator position) noexcept(noexcept(tree_.erase(position))) { tree_.erase(position); }

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

    void erase(iterator first, iterator last) noexcept(noexcept(tree_.erase(first, last))) { tree_.erase(first, last); }

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

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

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

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

    NEFORCE_NODISCARD iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); }

    NEFORCE_NODISCARD const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }

    NEFORCE_NODISCARD iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); }

    NEFORCE_NODISCARD const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); }

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

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

    void swap(multiset& other) noexcept(is_nothrow_swappable_v<base_type>) { tree_.swap(other.tree_); }

    NEFORCE_NODISCARD bool operator==(const multiset& rhs) const noexcept(noexcept(tree_ == rhs.tree_)) {
        return tree_ == rhs.tree_;
    }

    NEFORCE_NODISCARD bool operator<(const multiset& rhs) const noexcept(noexcept(tree_ < rhs.tree_)) {
        return tree_ < rhs.tree_;
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename Iterator, typename Compare = less<iter_value_t<Iterator>>,
          typename Alloc = allocator<iter_value_t<Iterator>>>
multiset(Iterator, Iterator, Compare = Compare(), Alloc = Alloc()) -> multiset<iter_value_t<Iterator>, Compare, Alloc>;
 
template <typename Key, typename Compare = less<Key>, typename Alloc = allocator<Key>>
multiset(std::initializer_list<Key>, Compare = Compare(), Alloc = Alloc()) -> multiset<Key, Compare, Alloc>;
 
template <typename Iterator, typename Alloc>
multiset(Iterator, Iterator, Alloc) -> multiset<iter_value_t<Iterator>, less<iter_value_t<Iterator>>, Alloc>;
 
template <typename Key, typename Alloc>
multiset(std::initializer_list<Key>, Alloc) -> multiset<Key, less<Key>, Alloc>;
#endif
 // Container
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_CONTAINER_MULTISET_HPP__