Classes
struct	value_compare

Public Types
using	allocator_type = typename std::vector< value_type >::allocator_type

using	const_iterator = typename std::vector< value_type >::const_iterator

using	const_pointer = typename std::vector< value_type >::const_pointer

using	const_reference = typename std::vector< value_type >::const_reference

using	const_reverse_iterator = typename std::vector< value_type >::const_reverse_iterator

using	difference_type = typename std::vector< value_type >::difference_type

using	iterator = typename std::vector< value_type >::iterator

using	key_compare = typename key_type::Comparator

using	key_type = Range< Key >

using	mapped_type = T

using	pointer = typename std::vector< value_type >::pointer

using	reference = typename std::vector< value_type >::reference

using	reverse_iterator = typename std::vector< value_type >::reverse_iterator

using	size_type = typename std::vector< value_type >::size_type

using	value_type = std::pair< key_type, mapped_type >

Public Member Functions
template<class InputIt , typename = std::enable_if_t<std::is_base_of_v< std::input_iterator_tag, typename std::iterator_traits<InputIt>::iterator_category>>>
	RangeMap (InputIt first, InputIt last)

	RangeMap (RangeMap &&other)

	RangeMap (RangeMap const &other)

template<typename Key2 >
	RangeMap (RangeMap< Key2, T > const &other)

	RangeMap (std::initializer_list< value_type > init)

const_iterator	begin () const noexcept

iterator	begin () noexcept

const_iterator	cbegin () const noexcept

const_iterator	cend () const noexcept

void	clear () noexcept

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
bool	contains (K key) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
bool	contains (K lower, K upper) const

bool	contains (key_type key) const

template<typename Key2 >
bool	contains (Range< Key2 > key) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
size_type	count (K key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
size_type	count (K lower, K upper)

size_type	count (key_type key) const

template<typename Key2 >
size_type	count (Range< Key2 > key)

const_reverse_iterator	crbegin () const noexcept

const_reverse_iterator	crend () const noexcept

template<class... Args>
std::pair< iterator, bool >	emplace (Args &&... args)

template<class... Args>
iterator	emplace_hint (const_iterator hint, Args &&... args)

bool	empty () const noexcept

const_iterator	end () const noexcept

iterator	end () noexcept

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
std::pair< iterator, iterator >	equal_range (K key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
std::pair< const_iterator, const_iterator >	equal_range (K key) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
std::pair< iterator, iterator >	equal_range (K lower, K upper)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
std::pair< const_iterator, const_iterator >	equal_range (K lower, K upper) const

std::pair< iterator, iterator >	equal_range (key_type key)

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

template<typename Key2 >
std::pair< iterator, iterator >	equal_range (Range< Key2 > key)

template<typename Key2 >
std::pair< const_iterator, const_iterator >	equal_range (Range< Key2 > key) const

iterator	erase (const_iterator first, const_iterator last)

iterator	erase (const_iterator pos)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
size_type	erase (K key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
size_type	erase (K lower, K upper)

size_type	erase (key_type key)

template<typename Key2 >
size_type	erase (Range< Key2 > key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
iterator	find (K key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
const_iterator	find (K key) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
iterator	find (K lower, K upper)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
const_iterator	find (K lower, K upper) const

iterator	find (key_type key)

const_iterator	find (key_type key) const

template<typename Key2 >
iterator	find (Range< Key2 > key)

template<typename Key2 >
const_iterator	find (Range< Key2 > key) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
T const &	get (K key)

allocator_type	get_allocator () const noexcept

template<class P >
iterator	insert (const_iterator hint, P &&value)

iterator	insert (const_iterator hint, value_type &&value)

iterator	insert (const_iterator hint, value_type const &value)

template<class InputIt , typename = std::enable_if_t<std::is_base_of_v< std::input_iterator_tag, typename std::iterator_traits<InputIt>::iterator_category>>>
void	insert (InputIt first, InputIt last)

template<class P , typename = std::enable_if_t<std::is_constructible_v<value_type, P&&>>>
std::pair< iterator, bool >	insert (P &&value)

void	insert (std::initializer_list< value_type > ilist)

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

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

template<class M >
iterator	insert_or_assign (const_iterator hint, key_type key, M &&obj)

template<class M >
std::pair< iterator, bool >	insert_or_assign (key_type key, M &&obj)

key_compare	key_comp () const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
iterator	lower_bound (K key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
const_iterator	lower_bound (K key) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
iterator	lower_bound (K lower, K upper)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
const_iterator	lower_bound (K lower, K upper) const

iterator	lower_bound (key_type key)

const_iterator	lower_bound (key_type key) const

template<typename Key2 >
iterator	lower_bound (Range< Key2 > key)

template<typename Key2 >
const_iterator	lower_bound (Range< Key2 > key) const

size_type	max_size () const noexcept

size_type	numRanges () const noexcept

template<typename Key2 = Key>
std::enable_if_t< std::is_integral_v< Key2 >, size_type >	numValues () const

RangeMap &	operator= (RangeMap &&other)

RangeMap &	operator= (RangeMap const &other)

template<typename Key2 >
RangeMap &	operator= (RangeMap< Key2, T > const &other)

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

const_reverse_iterator	rbegin () const noexcept

reverse_iterator	rbegin () noexcept

const_reverse_iterator	rend () const noexcept

reverse_iterator	rend () noexcept

size_type	size () const noexcept

void	swap (RangeMap &other) noexcept(std::allocator_traits< allocator_type >::is_always_equal::value &&std::is_nothrow_move_assignable< value_compare >::value)

template<class... Args>
iterator	try_emplace (const_iterator hint, key_type k, Args &&... args)

template<class... Args>
std::pair< iterator, bool >	try_emplace (key_type k, Args &&... args)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
iterator	upper_bound (K key)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
iterator	upper_bound (K lower, K upper)

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
const_iterator	upper_bound (K lower, K upper) const

template<typename K , typename = std::enable_if_t<std::is_arithmetic_v<K>>>
const_iterator	upper_bound (K value) const

iterator	upper_bound (key_type key)

const_iterator	upper_bound (key_type key) const

template<typename Key2 >
iterator	upper_bound (Range< Key2 > key)

template<typename Key2 >
const_iterator	upper_bound (Range< Key2 > key) const

value_compare	value_comp () const

Static Protected Member Functions
static constexpr Key	decrement (Key value)

static constexpr Key	increment (Key value)

Protected Attributes
value_compare	comp_

std::vector< value_type >	ranges_

Friends
template<typename K , typename M , class Pred >
size_type	erase_if (RangeMap< K, M > &range_set, Pred pred)

template<typename K , typename M >
bool	operator!= (RangeMap< K, M > const &lhs, RangeMap< K, M > const &rhs)

template<typename K , typename M >
bool	operator< (RangeMap< K, M > const &lhs, RangeMap< K, M > const &rhs)

template<typename K , typename M >
std::ostream &	operator<< (std::ostream &os, RangeMap< K, M > const &range_map)

template<typename K , typename M >
bool	operator<= (RangeMap< K, M > const &lhs, RangeMap< K, M > const &rhs)

template<typename K , typename M >
bool	operator== (RangeMap< K, M > const &lhs, RangeMap< K, M > const &rhs)

template<typename K , typename M >
bool	operator> (RangeMap< K, M > const &lhs, RangeMap< K, M > const &rhs)

template<typename K , typename M >
bool	operator>= (RangeMap< K, M > const &lhs, RangeMap< K, M > const &rhs)

template<typename K , typename M >
void	swap (RangeMap< K, M > &lhs, RangeMap< K, M > &rhs) noexcept(noexcept(lhs.swap(rhs)))

Detailed Description

template<typename Key, typename T>
class ufo::RangeMap< Key, T >

Definition at line 51 of file range_map.hpp.