flatmap.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_CONTAINERS_FLATMAP_H
#define CPPCOMMON_CONTAINERS_FLATMAP_H
 
#include <algorithm>
#include <cstddef>
#include <functional>
#include <iterator>
#include <limits>
#include <stdexcept>
#include <vector>
 
namespace CppCommon {
 
 
template <typename TKey, typename TValue, typename TCompare = std::less<TKey>, typename TAllocator = std::allocator<std::pair<TKey, TValue>>>
class FlatMap
{
public:
    // Standard container type definitions
    typedef TKey key_type;
    typedef TValue mapped_type;
    typedef std::pair<TKey, TValue> value_type;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef ptrdiff_t difference_type;
    typedef size_t size_type;
    typedef typename std::vector<value_type, TAllocator>::iterator iterator;
    typedef typename std::vector<value_type, TAllocator>::const_iterator const_iterator;
    typedef typename std::vector<value_type, TAllocator>::reverse_iterator reverse_iterator;
    typedef typename std::vector<value_type, TAllocator>::const_reverse_iterator const_reverse_iterator;
 
 
    explicit FlatMap(size_t capacity = 128, const TCompare& compare = TCompare(), const TAllocator& allocator = TAllocator());
    template <class InputIterator>
    FlatMap(InputIterator first, InputIterator last, bool unused, size_t capacity = 128, const TCompare& compare = TCompare(), const TAllocator& allocator = TAllocator());
    FlatMap(const FlatMap& flatmap);
    FlatMap(const FlatMap& flatmap, size_t capacity);
    FlatMap(FlatMap&&) noexcept = default;
    ~FlatMap() = default;
 
    FlatMap& operator=(const FlatMap& flatmap);
    FlatMap& operator=(FlatMap&&) noexcept = default;
 
    explicit operator bool() const noexcept { return !empty(); }
 
    mapped_type& operator[](const TKey& key) { return emplace_internal(key).first->second; }
 
    bool empty() const noexcept { return _container.empty(); }
 
    size_t capacity() const noexcept { return _container.capacity(); }
    size_t size() const noexcept { return _container.size(); }
    size_t max_size() const noexcept { return _container.max_size(); }
 
    bool compare(const TKey& key1, const TKey& key2) const noexcept { return _compare(key1, key2); }
    bool compare(const TKey& key1, const value_type& key2) const noexcept { return _compare(key1, key2.first); }
    bool compare(const value_type& key1, const TKey& key2) const noexcept { return _compare(key1.first, key2); }
    bool compare(const value_type& key1, const value_type& key2) const noexcept { return _compare(key1.first, key2.first); }
 
    iterator begin() noexcept { return _container.begin(); }
    const_iterator begin() const noexcept { return _container.begin(); }
    const_iterator cbegin() const noexcept { return _container.begin(); }
    iterator end() noexcept { return _container.end(); }
    const_iterator end() const noexcept { return _container.end(); }
    const_iterator cend() const noexcept { return _container.end(); }
 
    reverse_iterator rbegin() noexcept { return _container.rbegin(); }
    const_reverse_iterator rbegin() const noexcept { return _container.rbegin(); }
    const_reverse_iterator crbegin() const noexcept { return _container.rbegin(); }
    reverse_iterator rend() noexcept { return _container.rend(); }
    const_reverse_iterator rend() const noexcept { return _container.rend(); }
    const_reverse_iterator crend() const noexcept { return _container.rend(); }
 
    iterator find(const TKey& key) noexcept;
    const_iterator find(const TKey& key) const noexcept;
 
    iterator lower_bound(const TKey& key) noexcept;
    const_iterator lower_bound(const TKey& key) const noexcept;
    iterator upper_bound(const TKey& key) noexcept;
    const_iterator upper_bound(const TKey& key) const noexcept;
 
    std::pair<iterator, iterator> equal_range(const TKey& key) noexcept;
    std::pair<const_iterator, const_iterator> equal_range(const TKey& key) const noexcept;
 
    size_t count(const TKey& key) const noexcept { return (find(key) == end()) ? 0 : 1; }
 
 
    mapped_type& at(const TKey& key) noexcept;
 
    const mapped_type& at(const TKey& key) const noexcept;
 
 
    std::pair<iterator, bool> insert(const value_type& item);
 
    std::pair<iterator, bool> insert(value_type&& item);
 
    iterator insert(const const_iterator& position, const value_type& item);
 
    iterator insert(const const_iterator& position, value_type&& item);
 
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last);
 
 
    template <typename... Args>
    std::pair<iterator, bool> emplace(Args&&... args);
 
    template <typename... Args>
    iterator emplace_hint(const const_iterator& position, Args&&... args);
 
 
    size_t erase(const TKey& key);
 
    iterator erase(const const_iterator& position);
 
    iterator erase(const const_iterator& first, const const_iterator& last);
 
 
    void reserve(size_t count) { _container.reserve(count); }
 
    void shrink_to_fit() { _container.shrink_to_fit(); }
 
    void clear() noexcept { _container.clear(); }
 
    void swap(FlatMap& flatmap) noexcept;
    template <typename UKey, typename UValue, typename UCompare, typename UAllocator>
    friend void swap(FlatMap<UKey, UValue, UCompare, UAllocator>& flatmap1, FlatMap<UKey, UValue, UCompare, UAllocator>& flatmap2) noexcept;
 
private:
    TCompare _compare;                              // Flat map key comparator
    std::vector<value_type, TAllocator> _container; // Flat map container
 
    template <typename... Args>
    std::pair<iterator, bool> emplace_internal(const TKey& key, Args&&... args);
    template <typename... Args>
    iterator emplace_hint_internal(const const_iterator& position, const TKey& key, Args&&... args);
};
 
} // namespace CppCommon
 
#include "flatmap.inl"
 
#endif // CPPCOMMON_CONTAINERS_FLATMAP_H