flat.hpp

Library of flat vector-like based associative containers

Requirements

clang >= 7
gcc >= 7
msvc >= 2019
xcode >= 10.3

Installation

flat.hpp is a header-only library. All you need to do is copy the headers files from headers directory into your project and include them:

#include "flat.hpp/flat_set.hpp"

Also, you can add the root repository directory to your cmake project:

add_subdirectory(external/flat.hpp)
target_link_libraries(your_project_target PUBLIC flat.hpp::flat.hpp)

Flat Set

template < typename Key
         , typename Compare = std::less<Key>
         , typename Container = std::vector<Key> >
class flat_set;

Member types

Member type	Definition
`key_type`	`Key`
`value_type`	`Key`
`size_type`	`Container::size_type`
`difference_type`	`Container::difference_type`
`key_compare`	`Compare`
`value_compare`	`Compare`
`container_type`	`Container`
`reference`	`Container::reference`
`const_reference`	`Container::const_reference`
`pointer`	`Container::pointer`
`const_pointer`	`Container::const_pointer`
`iterator`	`Container::const_iterator`
`const_iterator`	`Container::const_iterator`
`reverse_iterator`	`Container::const_reverse_iterator`
`const_reverse_iterator`	`Container::const_reverse_iterator`

Member functions

flat_set();

explicit flat_set(const Compare& c);

template < typename Allocator >
explicit flat_set(const Allocator& a);

template < typename Allocator >
flat_set(const Compare& c, const Allocator& a);

template < typename InputIter >
flat_set(InputIter first, InputIter last);
template < typename InputIter >
flat_set(sorted_range_t, InputIter first, InputIter last);
template < typename InputIter >
flat_set(sorted_unique_range_t, InputIter first, InputIter last);

template < typename InputIter >
flat_set(InputIter first, InputIter last, const Compare& c);
template < typename InputIter >
flat_set(sorted_range_t, InputIter first, InputIter last, const Compare& c);
template < typename InputIter >
flat_set(sorted_unique_range_t, InputIter first, InputIter last, const Compare& c);

template < typename InputIter, typename Allocator >
flat_set(InputIter first, InputIter last, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_set(sorted_range_t, InputIter first, InputIter last, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_set(sorted_unique_range_t, InputIter first, InputIter last, const Allocator& a);

template < typename InputIter, typename Allocator >
flat_set(InputIter first, InputIter last, const Compare& c, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_set(sorted_range_t, InputIter first, InputIter last, const Compare& c, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_set(sorted_unique_range_t, InputIter first, InputIter last, const Compare& c, const Allocator& a);

flat_set(std::initializer_list<value_type> ilist);
flat_set(sorted_range_t, std::initializer_list<value_type> ilist);
flat_set(sorted_unique_range_t, std::initializer_list<value_type> ilist);

flat_set(std::initializer_list<value_type> ilist, const Compare& c);
flat_set(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c);
flat_set(sorted_unique_range_t, std::initializer_list<value_type> ilist, const Compare& c);

template < typename Allocator >
flat_set(std::initializer_list<value_type> ilist, const Allocator& a);
template < typename Allocator >
flat_set(sorted_range_t, std::initializer_list<value_type> ilist, const Allocator& a);
template < typename Allocator >
flat_set(sorted_unique_range_t, std::initializer_list<value_type> ilist, const Allocator& a);

template < typename Allocator >
flat_set(std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);
template < typename Allocator >
flat_set(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);
template < typename Allocator >
flat_set(sorted_unique_range_t, std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);

template < typename Allocator >
flat_set(flat_set&& other, const Allocator& a);

template < typename Allocator >
flat_set(const flat_set& other, const Allocator& a);

flat_set(flat_set&& other);
flat_set(const flat_set& other);

flat_set& operator=(flat_set&& other);
flat_set& operator=(const flat_set& other);

flat_set& operator=(std::initializer_list<value_type> ilist);

Iterators

iterator begin();
const_iterator begin() const;
const_iterator cbegin() const;

iterator end();
const_iterator end() const;
const_iterator cend() const;

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
const_reverse_iterator crbegin() const;

reverse_iterator rend();
const_reverse_iterator rend() const;
const_reverse_iterator crend() const;

Capacity

bool empty() const;
size_type size() const;
size_type max_size() const;
size_type capacity() const;
void reserve(size_type ncapacity);
void shrink_to_fit();

Modifiers

std::pair<iterator, bool> insert(value_type&& value);
std::pair<iterator, bool> insert(const value_type& value);

iterator insert(const_iterator hint, value_type&& value);
iterator insert(const_iterator hint, const value_type& value);

template < typename InputIter >
void insert(InputIter first, InputIter last);
template < typename InputIter >
void insert(sorted_range_t, InputIter first, InputIter last);

void insert(std::initializer_list<value_type> ilist);
void insert(sorted_range_t, std::initializer_list<value_type> ilist);

template < typename... Args >
std::pair<iterator, bool> emplace(Args&&... args);
template < typename... Args >
iterator emplace_hint(const_iterator hint, Args&&... args);

void clear();
iterator erase(const_iterator iter);
iterator erase(const_iterator first, const_iterator last);
size_type erase(const key_type& key);

void swap(flat_set& other);

Lookup

size_type count(const key_type& key) const;
template < typename K > size_type count(const K& key) const;

iterator find(const key_type& key);
const_iterator find(const key_type& key) const;

template < typename K > iterator find(const K& key);
template < typename K > const_iterator find(const K& key) const;

std::pair<iterator, iterator> equal_range(const key_type& key);
std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const;

template < typename K > std::pair<iterator, iterator> equal_range(const K& key);
template < typename K > std::pair<const_iterator, const_iterator> equal_range(const K& key) const;

iterator lower_bound(const key_type& key);
const_iterator lower_bound(const key_type& key) const;

template < typename K > iterator lower_bound(const K& key);
template < typename K > const_iterator lower_bound(const K& key) const;

iterator upper_bound(const key_type& key);
const_iterator upper_bound(const key_type& key) const;

template < typename K > iterator upper_bound(const K& key);
template < typename K > const_iterator upper_bound(const K& key) const;

Observers

key_compare key_comp() const;
value_compare value_comp() const;

Non-member functions

template < typename Key
         , typename Compare
         , typename Container >
void swap(
    flat_set<Key, Compare, Container>& l,
    flat_set<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator==(
    const flat_set<Key, Compare, Container>& l,
    const flat_set<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator!=(
    const flat_set<Key, Compare, Container>& l,
    const flat_set<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator<(
    const flat_set<Key, Compare, Container>& l,
    const flat_set<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator>(
    const flat_set<Key, Compare, Container>& l,
    const flat_set<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator<=(
    const flat_set<Key, Compare, Container>& l,
    const flat_set<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator>=(
    const flat_set<Key, Compare, Container>& l,
    const flat_set<Key, Compare, Container>& r);

Flat Map

template < typename Key
         , typename Value
         , typename Compare = std::less<Key>
         , typename Container = std::vector<std::pair<Key, Value>> >
class flat_map;

Member types

Member type	Definition
`key_type`	`Key`
`mapped_type`	`Value`
`value_type`	`Container::value_type`
`size_type`	`Container::size_type`
`difference_type`	`Container::difference_type`
`key_compare`	`Compare`
`container_type`	`Container`
`reference`	`Container::reference`
`const_reference`	`Container::const_reference`
`pointer`	`Container::pointer`
`const_pointer`	`Container::const_pointer`
`iterator`	`Container::iterator`
`const_iterator`	`Container::const_iterator`
`reverse_iterator`	`Container::reverse_iterator`
`const_reverse_iterator`	`Container::const_reverse_iterator`

Member classes

class value_compare;

Member functions

flat_map();

explicit flat_map(const Compare& c);

template < typename Allocator >
explicit flat_map(const Allocator& a);

template < typename Allocator >
flat_map(const Compare& c, const Allocator& a);

template < typename InputIter >
flat_map(InputIter first, InputIter last);
template < typename InputIter >
flat_map(sorted_range_t, InputIter first, InputIter last);
template < typename InputIter >
flat_map(sorted_unique_range_t, InputIter first, InputIter last);

template < typename InputIter >
flat_map(InputIter first, InputIter last, const Compare& c);
template < typename InputIter >
flat_map(sorted_range_t, InputIter first, InputIter last, const Compare& c);
template < typename InputIter >
flat_map(sorted_unique_range_t, InputIter first, InputIter last, const Compare& c);

template < typename InputIter, typename Allocator >
flat_map(InputIter first, InputIter last, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_map(sorted_range_t, InputIter first, InputIter last, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_map(sorted_unique_range_t, InputIter first, InputIter last, const Allocator& a);

template < typename InputIter , typename Allocator >
flat_map(InputIter first, InputIter last, const Compare& c, const Allocator& a);
template < typename InputIter , typename Allocator >
flat_map(sorted_range_t, InputIter first, InputIter last, const Compare& c, const Allocator& a);
template < typename InputIter , typename Allocator >
flat_map(sorted_unique_range_t, InputIter first, InputIter last, const Compare& c, const Allocator& a);

flat_map(std::initializer_list<value_type> ilist);
flat_map(sorted_range_t, std::initializer_list<value_type> ilist);
flat_map(sorted_unique_range_t, std::initializer_list<value_type> ilist);

flat_map(std::initializer_list<value_type> ilist, const Compare& c);
flat_map(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c);
flat_map(sorted_unique_range_t, std::initializer_list<value_type> ilist, const Compare& c);

template < typename Allocator >
flat_map(std::initializer_list<value_type> ilist, const Allocator& a);
template < typename Allocator >
flat_map(sorted_range_t, std::initializer_list<value_type> ilist, const Allocator& a);
template < typename Allocator >
flat_map(sorted_unique_range_t, std::initializer_list<value_type> ilist, const Allocator& a);

template < typename Allocator >
flat_map(std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);
template < typename Allocator >
flat_map(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);
template < typename Allocator >
flat_map(sorted_unique_range_t, std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);

template < typename Allocator >
flat_map(flat_map&& other, const Allocator& a);

template < typename Allocator >
flat_map(const flat_map& other, const Allocator& a);

flat_map(flat_map&& other);
flat_map(const flat_map& other);

flat_map& operator=(flat_map&& other);
flat_map& operator=(const flat_map& other);

flat_map& operator=(std::initializer_list<value_type> ilist);

Iterators

iterator begin();
const_iterator begin() const;
const_iterator cbegin() const;

iterator end();
const_iterator end() const;
const_iterator cend() const;

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
const_reverse_iterator crbegin() const;

reverse_iterator rend();
const_reverse_iterator rend() const;
const_reverse_iterator crend() const;

Capacity

bool empty() const;
size_type size() const;
size_type max_size() const;
size_type capacity() const;
void reserve(size_type ncapacity);
void shrink_to_fit();

Element access

mapped_type& operator[](key_type&& key);
mapped_type& operator[](const key_type& key);

mapped_type& at(const key_type& key);
const mapped_type& at(const key_type& key) const;

template < typename K > mapped_type& at(const K& key);
template < typename K > const mapped_type& at(const K& key) const;

Modifiers

std::pair<iterator, bool> insert(value_type&& value);
std::pair<iterator, bool> insert(const value_type& value);

iterator insert(const_iterator hint, value_type&& value);
iterator insert(const_iterator hint, const value_type& value);

template < typename TT >
std::pair<iterator, bool> insert_or_assign(key_type&& key, TT&& value);
template < typename TT >
std::pair<iterator, bool> insert_or_assign(const key_type& key, TT&& value);

template < typename InputIter >
void insert(InputIter first, InputIter last);
template < typename InputIter >
void insert(sorted_range_t, InputIter first, InputIter last);

void insert(std::initializer_list<value_type> ilist);
void insert(sorted_range_t, std::initializer_list<value_type> ilist);

template < typename... Args >
std::pair<iterator, bool> emplace(Args&&... args);
template < typename... Args >
iterator emplace_hint(const_iterator hint, Args&&... args);

template < typename... Args >
std::pair<iterator, bool> try_emplace(key_type&& key, Args&&... args);
template < typename... Args >
std::pair<iterator, bool> try_emplace(const key_type& key, Args&&... args);

void clear();
iterator erase(const_iterator iter);
iterator erase(const_iterator first, const_iterator last);
size_type erase(const key_type& key);

void swap(flat_map& other)

Lookup

size_type count(const key_type& key) const;
template < typename K > size_type count(const K& key) const;

iterator find(const key_type& key);
const_iterator find(const key_type& key) const;

template < typename K > iterator find(const K& key);
template < typename K > const_iterator find(const K& key) const;

std::pair<iterator, iterator> equal_range(const key_type& key);
std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const;

template < typename K > std::pair<iterator, iterator> equal_range(const K& key);
template < typename K > std::pair<const_iterator, const_iterator> equal_range(const K& key) const;

iterator lower_bound(const key_type& key);
const_iterator lower_bound(const key_type& key) const;

template < typename K > iterator lower_bound(const K& key);
template < typename K > const_iterator lower_bound(const K& key) const;

iterator upper_bound(const key_type& key);
const_iterator upper_bound(const key_type& key) const;

template < typename K > iterator upper_bound(const K& key);
template < typename K > const_iterator upper_bound(const K& key) const;

Observers

key_compare key_comp() const;
value_compare value_comp() const;

Non-member functions

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
void swap(
    flat_map<Key, Value, Compare, Container>& l,
    flat_map<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator==(
    const flat_map<Key, Value, Compare, Container>& l,
    const flat_map<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator!=(
    const flat_map<Key, Value, Compare, Container>& l,
    const flat_map<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator<(
    const flat_map<Key, Value, Compare, Container>& l,
    const flat_map<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator>(
    const flat_map<Key, Value, Compare, Container>& l,
    const flat_map<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator<=(
    const flat_map<Key, Value, Compare, Container>& l,
    const flat_map<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator>=(
    const flat_map<Key, Value, Compare, Container>& l,
    const flat_map<Key, Value, Compare, Container>& r);

Flat Multiset

template < typename Key
         , typename Compare = std::less<Key>
         , typename Container = std::vector<Key> >
class flat_multiset;

Member types

Member type	Definition
`key_type`	`Key`
`value_type`	`Key`
`size_type`	`Container::size_type`
`difference_type`	`Container::difference_type`
`key_compare`	`Compare`
`value_compare`	`Compare`
`container_type`	`Container`
`reference`	`Container::reference`
`const_reference`	`Container::const_reference`
`pointer`	`Container::pointer`
`const_pointer`	`Container::const_pointer`
`iterator`	`Container::const_iterator`
`const_iterator`	`Container::const_iterator`
`reverse_iterator`	`Container::const_reverse_iterator`
`const_reverse_iterator`	`Container::const_reverse_iterator`

Member functions

flat_multiset();

explicit flat_multiset(const Compare& c);

template < typename Allocator >
explicit flat_multiset(const Allocator& a);

template < typename Allocator >
flat_multiset(const Compare& c, const Allocator& a);

template < typename InputIter >
flat_multiset(InputIter first, InputIter last);
template < typename InputIter >
flat_multiset(sorted_range_t, InputIter first, InputIter last);

template < typename InputIter >
flat_multiset(InputIter first, InputIter last, const Compare& c);
template < typename InputIter >
flat_multiset(sorted_range_t, InputIter first, InputIter last, const Compare& c);

template < typename InputIter, typename Allocator >
flat_multiset(InputIter first, InputIter last, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_multiset(sorted_range_t, InputIter first, InputIter last, const Allocator& a);

template < typename InputIter, typename Allocator >
flat_multiset(InputIter first, InputIter last, const Compare& c, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_multiset(sorted_range_t, InputIter first, InputIter last, const Compare& c, const Allocator& a);

flat_multiset(std::initializer_list<value_type> ilist);
flat_multiset(sorted_range_t, std::initializer_list<value_type> ilist);

flat_multiset(std::initializer_list<value_type> ilist, const Compare& c);
flat_multiset(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c);

template < typename Allocator >
flat_multiset(std::initializer_list<value_type> ilist, const Allocator& a);
template < typename Allocator >
flat_multiset(sorted_range_t, std::initializer_list<value_type> ilist, const Allocator& a);

template < typename Allocator >
flat_multiset(std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);
template < typename Allocator >
flat_multiset(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);

template < typename Allocator >
flat_multiset(flat_multiset&& other, const Allocator& a);

template < typename Allocator >
flat_multiset(const flat_multiset& other, const Allocator& a);

flat_multiset(flat_multiset&& other);
flat_multiset(const flat_multiset& other);

flat_multiset& operator=(flat_multiset&& other);
flat_multiset& operator=(const flat_multiset& other);

flat_multiset& operator=(std::initializer_list<value_type> ilist);

Iterators

iterator begin();
const_iterator begin() const;
const_iterator cbegin() const;

iterator end();
const_iterator end() const;
const_iterator cend() const;

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
const_reverse_iterator crbegin() const;

reverse_iterator rend();
const_reverse_iterator rend() const;
const_reverse_iterator crend() const;

Capacity

bool empty() const;
size_type size() const;
size_type max_size() const;
size_type capacity() const;
void reserve(size_type ncapacity);
void shrink_to_fit();

Modifiers

iterator insert(value_type&& value);
iterator insert(const value_type& value);

iterator insert(const_iterator hint, value_type&& value);
iterator insert(const_iterator hint, const value_type& value);

template < typename InputIter >
void insert(InputIter first, InputIter last);
template < typename InputIter >
void insert(sorted_range_t, InputIter first, InputIter last);

void insert(std::initializer_list<value_type> ilist);
void insert(sorted_range_t, std::initializer_list<value_type> ilist);

template < typename... Args >
iterator emplace(Args&&... args);
template < typename... Args >
iterator emplace_hint(const_iterator hint, Args&&... args);

void clear();
iterator erase(const_iterator iter);
iterator erase(const_iterator first, const_iterator last);
size_type erase(const key_type& key);

void swap(flat_multiset& other);

Lookup

size_type count(const key_type& key) const;
template < typename K > size_type count(const K& key) const;

iterator find(const key_type& key);
const_iterator find(const key_type& key) const;

template < typename K > iterator find(const K& key);
template < typename K > const_iterator find(const K& key) const;

std::pair<iterator, iterator> equal_range(const key_type& key);
std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const;

template < typename K > std::pair<iterator, iterator> equal_range(const K& key);
template < typename K > std::pair<const_iterator, const_iterator> equal_range(const K& key) const;

iterator lower_bound(const key_type& key);
const_iterator lower_bound(const key_type& key) const;

template < typename K > iterator lower_bound(const K& key);
template < typename K > const_iterator lower_bound(const K& key) const;

iterator upper_bound(const key_type& key);
const_iterator upper_bound(const key_type& key) const;

template < typename K > iterator upper_bound(const K& key);
template < typename K > const_iterator upper_bound(const K& key) const;

Observers

key_compare key_comp() const;
value_compare value_comp() const;

Non-member functions

template < typename Key
         , typename Compare
         , typename Container >
void swap(
    flat_multiset<Key, Compare, Container>& l,
    flat_multiset<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator==(
    const flat_multiset<Key, Compare, Container>& l,
    const flat_multiset<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator!=(
    const flat_multiset<Key, Compare, Container>& l,
    const flat_multiset<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator<(
    const flat_multiset<Key, Compare, Container>& l,
    const flat_multiset<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator>(
    const flat_multiset<Key, Compare, Container>& l,
    const flat_multiset<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator<=(
    const flat_multiset<Key, Compare, Container>& l,
    const flat_multiset<Key, Compare, Container>& r);

template < typename Key
         , typename Compare
         , typename Container >
bool operator>=(
    const flat_multiset<Key, Compare, Container>& l,
    const flat_multiset<Key, Compare, Container>& r);

Flat Multimap

template < typename Key
         , typename Value
         , typename Compare = std::less<Key>
         , typename Container = std::vector<std::pair<Key, Value>> >
class flat_multimap;

Member types

Member type	Definition
`key_type`	`Key`
`mapped_type`	`Value`
`value_type`	`Container::value_type`
`size_type`	`Container::size_type`
`difference_type`	`Container::difference_type`
`key_compare`	`Compare`
`container_type`	`Container`
`reference`	`Container::reference`
`const_reference`	`Container::const_reference`
`pointer`	`Container::pointer`
`const_pointer`	`Container::const_pointer`
`iterator`	`Container::iterator`
`const_iterator`	`Container::const_iterator`
`reverse_iterator`	`Container::reverse_iterator`
`const_reverse_iterator`	`Container::const_reverse_iterator`

Member classes

class value_compare;

Member functions

flat_multimap();

explicit flat_multimap(const Compare& c);

template < typename Allocator >
explicit flat_multimap(const Allocator& a);

template < typename Allocator >
flat_multimap(const Compare& c, const Allocator& a);

template < typename InputIter >
flat_multimap(InputIter first, InputIter last);
template < typename InputIter >
flat_multimap(sorted_range_t, InputIter first, InputIter last);

template < typename InputIter >
flat_multimap(InputIter first, InputIter last, const Compare& c);
template < typename InputIter >
flat_multimap(sorted_range_t, InputIter first, InputIter last, const Compare& c);

template < typename InputIter, typename Allocator >
flat_multimap(InputIter first, InputIter last, const Allocator& a);
template < typename InputIter, typename Allocator >
flat_multimap(sorted_range_t, InputIter first, InputIter last, const Allocator& a);

template < typename InputIter , typename Allocator >
flat_multimap(InputIter first, InputIter last, const Compare& c, const Allocator& a);
template < typename InputIter , typename Allocator >
flat_multimap(sorted_range_t, InputIter first, InputIter last, const Compare& c, const Allocator& a);

flat_multimap(std::initializer_list<value_type> ilist);
flat_multimap(sorted_range_t, std::initializer_list<value_type> ilist);

flat_multimap(std::initializer_list<value_type> ilist, const Compare& c);
flat_multimap(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c);

template < typename Allocator >
flat_multimap(std::initializer_list<value_type> ilist, const Allocator& a);
template < typename Allocator >
flat_multimap(sorted_range_t, std::initializer_list<value_type> ilist, const Allocator& a);

template < typename Allocator >
flat_multimap(std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);
template < typename Allocator >
flat_multimap(sorted_range_t, std::initializer_list<value_type> ilist, const Compare& c, const Allocator& a);

template < typename Allocator >
flat_multimap(flat_multimap&& other, const Allocator& a);

template < typename Allocator >
flat_multimap(const flat_multimap& other, const Allocator& a);

flat_multimap(flat_multimap&& other);
flat_multimap(const flat_multimap& other);

flat_multimap& operator=(flat_multimap&& other);
flat_multimap& operator=(const flat_multimap& other);

flat_multimap& operator=(std::initializer_list<value_type> ilist);

Iterators

iterator begin();
const_iterator begin() const;
const_iterator cbegin() const;

iterator end();
const_iterator end() const;
const_iterator cend() const;

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
const_reverse_iterator crbegin() const;

reverse_iterator rend();
const_reverse_iterator rend() const;
const_reverse_iterator crend() const;

Capacity

bool empty() const;
size_type size() const;
size_type max_size() const;
size_type capacity() const;
void reserve(size_type ncapacity);
void shrink_to_fit();

Element access

mapped_type& operator[](key_type&& key);
mapped_type& operator[](const key_type& key);

mapped_type& at(const key_type& key);
const mapped_type& at(const key_type& key) const;

template < typename K > mapped_type& at(const K& key);
template < typename K > const mapped_type& at(const K& key) const;

Modifiers

iterator insert(value_type&& value);
iterator insert(const value_type& value);

iterator insert(const_iterator hint, value_type&& value);
iterator insert(const_iterator hint, const value_type& value);

template < typename InputIter >
void insert(InputIter first, InputIter last);
template < typename InputIter >
void insert(sorted_range_t, InputIter first, InputIter last);

void insert(std::initializer_list<value_type> ilist);
void insert(sorted_range_t, std::initializer_list<value_type> ilist);

template < typename... Args >
iterator emplace(Args&&... args);
template < typename... Args >
iterator emplace_hint(const_iterator hint, Args&&... args);

void clear();
iterator erase(const_iterator iter);
iterator erase(const_iterator first, const_iterator last);
size_type erase(const key_type& key);

void swap(flat_multimap& other)

Lookup

size_type count(const key_type& key) const;
template < typename K > size_type count(const K& key) const;

iterator find(const key_type& key);
const_iterator find(const key_type& key) const;

template < typename K > iterator find(const K& key);
template < typename K > const_iterator find(const K& key) const;

std::pair<iterator, iterator> equal_range(const key_type& key);
std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const;

template < typename K > std::pair<iterator, iterator> equal_range(const K& key);
template < typename K > std::pair<const_iterator, const_iterator> equal_range(const K& key) const;

iterator lower_bound(const key_type& key);
const_iterator lower_bound(const key_type& key) const;

template < typename K > iterator lower_bound(const K& key);
template < typename K > const_iterator lower_bound(const K& key) const;

iterator upper_bound(const key_type& key);
const_iterator upper_bound(const key_type& key) const;

template < typename K > iterator upper_bound(const K& key);
template < typename K > const_iterator upper_bound(const K& key) const;

Observers

key_compare key_comp() const;
value_compare value_comp() const;

Non-member functions

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
void swap(
    flat_multimap<Key, Value, Compare, Container>& l,
    flat_multimap<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator==(
    const flat_multimap<Key, Value, Compare, Container>& l,
    const flat_multimap<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator!=(
    const flat_multimap<Key, Value, Compare, Container>& l,
    const flat_multimap<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator<(
    const flat_multimap<Key, Value, Compare, Container>& l,
    const flat_multimap<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator>(
    const flat_multimap<Key, Value, Compare, Container>& l,
    const flat_multimap<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator<=(
    const flat_multimap<Key, Value, Compare, Container>& l,
    const flat_multimap<Key, Value, Compare, Container>& r);

template < typename Key
         , typename Value
         , typename Compare
         , typename Container >
bool operator>=(
    const flat_multimap<Key, Value, Compare, Container>& l,
    const flat_multimap<Key, Value, Compare, Container>& r);

License (MIT)

This site is open source. Improve this page.