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);

Name	Name	Last commit message	Last commit date
Latest commit BlackMATov Merge pull request #36 from BlackMATov/dev Jan 5, 2023 a010218 · Jan 5, 2023 History 103 Commits
.github/workflows	.github/workflows	new ci scripts and presets	Dec 28, 2022
.vscode	.vscode	add cmake install targets	Jan 5, 2023
cmake	cmake	add cmake install targets	Jan 5, 2023
headers/flat.hpp	headers/flat.hpp	Happy New Year 🥳	Jan 5, 2023
untests	untests	add cmake install targets	Jan 5, 2023
vendors	vendors	new ci scripts and presets	Dec 28, 2022
.clang-tidy	.clang-tidy	new ci scripts and presets	Dec 28, 2022
.gitignore	.gitignore	add cmake install targets	Jan 5, 2023
.gitmodules	.gitmodules	new ci scripts and presets	Dec 28, 2022
CMakeLists.txt	CMakeLists.txt	add cmake install targets	Jan 5, 2023
CMakePresets.json	CMakePresets.json	new ci scripts and presets	Dec 28, 2022
LICENSE.md	LICENSE.md	Happy New Year 🥳	Jan 5, 2023
README.md	README.md	add cmake install targets	Jan 5, 2023

License

BlackMATov/flat.hpp

Folders and files

Latest commit

History

Repository files navigation

flat.hpp

Requirements

Installation

API

Flat Set

Member types

Member functions

Iterators

Capacity

Modifiers

Lookup

Observers

Non-member functions

Flat Map

Member types

Member classes

Member functions

Iterators

Capacity

Element access

Modifiers

Lookup

Observers

Non-member functions

Flat Multiset

Member types

Member functions

Iterators

Capacity

Modifiers

Lookup

Observers

Non-member functions

Flat Multimap

Member types

Member classes

Member functions

Iterators

Capacity

Element access

Modifiers

Lookup

Observers

Non-member functions

License (MIT)

About

Topics

Resources

License

Stars

Watchers

Forks

Releases

Languages