A std::map compatible map, useful when we do not have many elements (less then 512) More...

#include <tpie/tiny.h>

Inherits tpie::tiny::set_impl< std::pair< Key, T >, T, bits::PairExtract< Key, T >, std::less< Key >, std::allocator< std::pair< Key, T > >, bits::SingleInsertHelp >.

Public Types
typedef std::pair< Key, T >	value_type

typedef T	key_type

typedef Inner::iterator	iterator

typedef Inner::const_iterator	const_iterator

typedef Inner::reverse_iterator	reverse_iterator

typedef Inner::const_reverse_iterator	const_reverse_iterator

typedef std::less< Key >	key_compare

typedef std::allocator< std::pair< Key, T > >	allocator_type

typedef IH::result	insert_result

Public Member Functions
	map (const Comp &comp, const Alloc &alloc=Alloc())

	map (const Alloc &alloc)

	map (const map &other)

	map (const map &other, const Alloc &alloc)

	map (map &&other)

	map (map &&other, const Alloc &alloc)

template<class InputIterator >
	map (InputIterator first, InputIterator last, const Comp &comp=Comp(), const Alloc &alloc=Alloc())

	map (std::initializer_list< typename P::value_type > init, const Comp &comp=Comp(), const Alloc &alloc=Alloc())

T &	operator[] (const Key &key)
	Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist. More...

T &	operator[] (Key &&key)
	Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist. More...

T &	at (const Key &key)
	Returns a reference to the mapped value of the element with key equivalent to key. More...

const T &	at (const Key &key) const
	Returns a reference to the mapped value of the element with key equivalent to key. More...

iterator	begin () noexcept
	Returns an iterator to the first element of the container. More...

const_iterator	begin () const noexcept
	Returns an iterator to the first element of the container. More...

const_iterator	cbegin () const noexcept
	Returns an iterator to the first element of the container. More...

reverse_iterator	rbegin () noexcept
	Returns a reverse iterator to the first element of the reversed container. More...

const_reverse_iterator	rbegin () const noexcept
	Returns a reverse iterator to the first element of the reversed container. More...

const_reverse_iterator	crbegin () const noexcept
	Returns a reverse iterator to the first element of the reversed container. More...

iterator	end () noexcept
	Returns an iterator to the element following the last element of the container. More...

const_iterator	end () const noexcept
	Returns an iterator to the element following the last element of the container. More...

const_iterator	cend () const noexcept
	Returns an iterator to the element following the last element of the container. More...

reverse_iterator	rend () noexcept
	Returns a reverse iterator to the element following the last element of the reversed container. More...

const_reverse_iterator	rend () const noexcept
	Returns a reverse iterator to the element following the last element of the reversed container. More...

const_reverse_iterator	crend () const noexcept
	Returns a reverse iterator to the element following the last element of the reversed container. More...

bool	empty () const noexcept
	Checks if the container has no elements, i.e. More...

size_t	size () const noexcept
	Returns the number of elements in the container, i.e. More...

size_t	max_size () const noexcept
	Returns the maximum number of elements the container is able to hold due to system or library implementation limitations. More...

void	clear ()
	Removes all elements from the container. More...

iterator	erase (iterator pos)
	Removes the element at pos. More...

iterator	erase (iterator first, iterator last)
	Removes the elements in the range [first; last), which must be a valid range in *this. More...

size_t	erase (const T &key)
	Removes all elements with the key value key. More...

void	swap (set_impl &o)
	Exchanges the contents of the container with those of other. More...

iterator	find (const T &key) noexcept
	Finds an element with key equivalent to key. More...

const_iterator	find (const T &key) const noexcept
	Finds an element with key equivalent to key. More...

std::pair< iterator, iterator >	equal_range (const T &key) noexcept
	Returns a range containing all elements with the given key in the container. More...

std::pair< const_iterator, const_iterator >	equal_range (const T &key) const noexcept
	Returns a range containing all elements with the given key in the container. More...

iterator	lower_bound (const T &key) noexcept
	Returns an iterator pointing to the first element that is not less than key. More...

const_iterator	lower_bound (const T &key) const noexcept
	Returns an iterator pointing to the first element that is not less than key. More...

iterator	lower_bound (const K &key) noexcept
	Returns an iterator pointing to the first element that is not less than key. More...

const_iterator	lower_bound (const K &key) const noexcept
	Returns an iterator pointing to the first element that is not less than key. More...

iterator	upper_bound (const T &key) noexcept
	Returns an iterator pointing to the first element that is greater than key. More...

const_iterator	upper_bound (const T &key) const noexcept
	Returns an iterator pointing to the first element that is greater than key. More...

iterator	upper_bound (const K &key) noexcept
	Returns an iterator pointing to the first element that is greater than key. More...

const_iterator	upper_bound (const K &key) const noexcept
	Returns an iterator pointing to the first element that is greater than key. More...

key_compare	key_comp () const noexcept
	Returns the function object that compares the keys, which is a copy of this container's constructor argument comp. More...

value_compare	value_comp () const noexcept
	Returns a function object that compares objects of type std::map::value_type (key-value pairs) by using key_comp to compare the first components of the pairs. More...

allocator_type	get_allocator () const
	Returns the allocator associated with the container. More...

size_t	count (const T k) const noexcept
	Returns the number of elements with key k. More...

insert_result	insert (const std::pair< Key, T > &t)
	Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key. More...

insert_result	insert (TT &&t)
	Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key. More...

insert_result	insert (const_iterator, const std::pair< Key, T > &t)
	Does the same as normal insert, we ignore the hint. More...

insert_result	insert (const_iterator, TT &&t)
	Does the same as normal insert, we ignore the hint. More...

void	insert (InputIt first, InputIt last)
	Inserts elements from range [first, last). More...

void	insert (std::initializer_list< value_type > list)
	Inserts elements from initializer list ilist. More...

insert_result	emplace (Args &&... args)
	Inserts a new element into the container by constructing it in-place with the given args if there is no element with the key in the container. More...

insert_result	emplace_hint (const_iterator, Args &&... args)
	Do the same as emplace, and ignore the hint. More...

void	reserve (size_t new_cap)
	Increase the capacity of the container to a value that's greater or equal to new_cap. More...

void	shrink_to_fit ()
	Requests the removal of unused capacity. More...

size_t	capacity () const noexcept
	Returns the number of elements that the container has currently allocated space for. More...

Protected Types
typedef std::vector< std::pair< Key, T >, std::allocator< std::pair< Key, T > > >	Inner

typedef bits::SingleInsertHelp ::template type< Inner >	IH

Protected Attributes
value_compare	comp

std::vector< value_type, std::allocator< std::pair< Key, T > > >	inner

Detailed Description

template<typename Key, typename T, typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >>
class tpie::tiny::map< Key, T, Comp, Alloc >

A std::map compatible map, useful when we do not have many elements (less then 512)

Definition at line 713 of file tiny.h.

Member Function Documentation

◆ at() [1/2]

template<typename Key , typename T , typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >>

T& tpie::tiny::map< Key, T, Comp, Alloc >::at ( const Key & key )

inline

Returns a reference to the mapped value of the element with key equivalent to key.

If no such element exists, an exception of type std::out_of_range is thrown.

Definition at line 758 of file tiny.h.

                             {
         typename P::iterator x=P::lower_bound(key);
         if (x == P::end() || P::comp(key, *x)) throw std::out_of_range("tiny::map::at");
         return x->second;
     }

References tpie::tiny::set_impl< T, Key, KeyExtract, Comp, Alloc, InsertHelp >::end(), and tpie::tiny::set_impl< T, Key, KeyExtract, Comp, Alloc, InsertHelp >::lower_bound().

◆ at() [2/2]

template<typename Key , typename T , typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >>

const T& tpie::tiny::map< Key, T, Comp, Alloc >::at ( const Key & key ) const

inline

Returns a reference to the mapped value of the element with key equivalent to key.

If no such element exists, an exception of type std::out_of_range is thrown.

Definition at line 769 of file tiny.h.

                                         {
         typename P::const_iterator x=P::lower_bound(key);
         if (x == P::end() || P::comp(key, *x)) throw std::out_of_range("tiny::map::at");
         return x->second;
     }

References tpie::tiny::set_impl< T, Key, KeyExtract, Comp, Alloc, InsertHelp >::end(), and tpie::tiny::set_impl< T, Key, KeyExtract, Comp, Alloc, InsertHelp >::lower_bound().

◆ begin() [1/2]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::begin

inlinenoexceptinherited

Returns an iterator to the first element of the container.

Definition at line 224 of file tiny.h.

224 {return inner.cbegin();}

◆ begin() [2/2]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::begin

inlinenoexceptinherited

Returns an iterator to the first element of the container.

Definition at line 219 of file tiny.h.

219 {return inner.begin();}

◆ capacity()

size_t tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::capacity

inlinenoexceptinherited

Returns the number of elements that the container has currently allocated space for.

Definition at line 675 of file tiny.h.

675 {return inner.capacity();}

◆ cbegin()

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::cbegin

inlinenoexceptinherited

Returns an iterator to the first element of the container.

Definition at line 229 of file tiny.h.

229 {return inner.cbegin();}

◆ cend()

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::cend

inlinenoexceptinherited

Returns an iterator to the element following the last element of the container.

Definition at line 259 of file tiny.h.

259 {return inner.cend();}

◆ clear()

void tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::clear

inlineinherited

Removes all elements from the container.

Definition at line 300 of file tiny.h.

300 {inner.clear(); }

◆ count()

size_t tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::count ( const T k ) const

inlinenoexceptinherited

Returns the number of elements with key k.

Definition at line 563 of file tiny.h.

                                              {
         if (IH::multi) {
             auto x=equal_range(k);
             return x.second - x.first;
         } else {
             auto x=lower_bound(k);
             if (x == end() || comp(k, *x)) return 0;
             return 1;
         }
     }

◆ crbegin()

const_reverse_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::crbegin

inlinenoexceptinherited

Returns a reverse iterator to the first element of the reversed container.

Definition at line 244 of file tiny.h.

244 {return inner.rbegin();}

◆ crend()

const_reverse_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::crend

inlinenoexceptinherited

Returns a reverse iterator to the element following the last element of the reversed container.

Definition at line 277 of file tiny.h.

277 {return inner.rend();}

◆ emplace()

insert_result tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::emplace ( Args &&... args )

inlineinherited

Inserts a new element into the container by constructing it in-place with the given args if there is no element with the key in the container.

Returns: Returns a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place.

Definition at line 645 of file tiny.h.

                                            {
         inner.emplace_back(std::forward<Args>(args)...);
         return IH::handle(inner, comp);
     }

◆ emplace_hint()

insert_result tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::emplace_hint	(	const_iterator	,
		Args &&...	args
	)

inlineinherited

Do the same as emplace, and ignore the hint.

Definition at line 654 of file tiny.h.

                                                                   {
         return emplace(std::forward<Args>(args)...);
     }

◆ empty()

bool tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::empty

inlinenoexceptinherited

Checks if the container has no elements, i.e.

whether begin() == end().

Definition at line 283 of file tiny.h.

283 {return inner.empty();}

◆ end() [1/2]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::end

inlinenoexceptinherited

Returns an iterator to the element following the last element of the container.

Definition at line 254 of file tiny.h.

254 {return inner.cend();}

◆ end() [2/2]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::end

inlinenoexceptinherited

Returns an iterator to the element following the last element of the container.

Definition at line 249 of file tiny.h.

249 {return inner.end();}

◆ equal_range() [1/2]

std::pair<const_iterator, const_iterator> tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::equal_range ( const T & key ) const

inlinenoexceptinherited

Returns a range containing all elements with the given key in the container.

The range is defined by two iterators, one pointing to the first element that is not less than key and another pointing to the first element greater than key.

Definition at line 380 of file tiny.h.

                                                                                         {
         return std::equal_range(inner.begin(), inner.end(), key, comp);
     }

◆ equal_range() [2/2]

std::pair<iterator, iterator> tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::equal_range ( const T & key )

inlinenoexceptinherited

Returns a range containing all elements with the given key in the container.

The range is defined by two iterators, one pointing to the first element that is not less than key and another pointing to the first element greater than key.

Definition at line 370 of file tiny.h.

                                                                       {
         return std::equal_range(inner.begin(), inner.end(), key, comp);
     }

◆ erase() [1/3]

size_t tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::erase ( const T & key )

inlineinherited

Removes all elements with the key value key.

Returns: Number of elements removed.

Definition at line 327 of file tiny.h.

                                   {
         auto x=equal_range(key);
         auto res = x.second - x.first;
         erase(x.first, x.second);
         return res;
     }

◆ erase() [2/3]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::erase	(	iterator	first,
		iterator	last
	)

inlineinherited

Removes the elements in the range [first; last), which must be a valid range in *this.

Returns: Iterator following the last removed element.

Definition at line 317 of file tiny.h.

                                                   {
         std::rotate(first, last, inner.end());
         inner.resize(size() - (last-first));
         return begin();
     }

◆ erase() [3/3]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::erase ( iterator pos )

inlineinherited

Removes the element at pos.

Returns: Iterator following the last removed element.

Definition at line 306 of file tiny.h.

                                  {
         std::rotate(pos, std::next(pos), inner.end());
         inner.pop_back();
         return pos;
     }

◆ find() [1/2]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::find ( const T & key ) const

inlinenoexceptinherited

Finds an element with key equivalent to key.

If no such element is found, past-the-end iterator is returned.

Definition at line 358 of file tiny.h.

                                                         {
         const_iterator x=lower_bound(key);
         if (x == end() || comp(key, *x)) return end();
         return x;
     }

◆ find() [2/2]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::find ( const T & key )

inlinenoexceptinherited

Finds an element with key equivalent to key.

If no such element is found, past-the-end iterator is returned.

Definition at line 348 of file tiny.h.

                                             {
         iterator x=lower_bound(key);
         if (x == end() || comp(key, *x)) return end();
         return x;
     }

◆ get_allocator()

allocator_type tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::get_allocator

inlineinherited

Returns the allocator associated with the container.

Definition at line 473 of file tiny.h.

                                          {
         return inner.get_allocator();
     }

◆ insert() [1/6]

insert_result tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::insert ( const std::pair< Key, T > & t )

inlineinherited

Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.

Returns: Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a bool denoting whether the insertion took place.

Definition at line 583 of file tiny.h.

                                       {
         inner.push_back(t);
         return IH::handle(inner, comp);
     }

◆ insert() [2/6]

insert_result tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::insert	(	const_iterator	,
		const std::pair< Key, T > &	t
	)

inlineinherited

Does the same as normal insert, we ignore the hint.

Definition at line 605 of file tiny.h.

                                                         {
         return insert(t);
     }

◆ insert() [3/6]

insert_result tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::insert	(	const_iterator	,
		TT &&	t
	)

inlineinherited

Does the same as normal insert, we ignore the hint.

Definition at line 613 of file tiny.h.

                                                     {
         return insert(std::forward<TT>(t));
     }

◆ insert() [4/6]

void tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::insert	(	InputIt	first,
		InputIt	last
	)

inlineinherited

Inserts elements from range [first, last).

Definition at line 621 of file tiny.h.

                                              {
         inner.reserve(size() + last-first);
         for (InputIt i=first; i != last; ++i)
             insert(*i);
     }

◆ insert() [5/6]

void tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::insert ( std::initializer_list< value_type > list )

inlineinherited

Inserts elements from initializer list ilist.

Definition at line 630 of file tiny.h.

                                                       {
         insert(list.begin(), list.end());
     }

◆ insert() [6/6]

insert_result tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::insert ( TT && t )

inlineinherited

Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.

Returns: Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a bool denoting whether the insertion took place.

Definition at line 598 of file tiny.h.

                                   {
         return emplace(std::forward<TT>(t));
     }

◆ key_comp()

key_compare tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::key_comp

inlinenoexceptinherited

Returns the function object that compares the keys, which is a copy of this container's constructor argument comp.

Definition at line 457 of file tiny.h.

                                           {
         return comp.comp;
     }

◆ lower_bound() [1/4]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::lower_bound ( const K & key ) const

inlinenoexceptinherited

Returns an iterator pointing to the first element that is not less than key.

Definition at line 430 of file tiny.h.

                                                              {
         return std::lower_bound(inner.begin(), inner.end(), key, comp);
     }

◆ lower_bound() [2/4]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::lower_bound ( const K & key )

inlinenoexceptinherited

Returns an iterator pointing to the first element that is not less than key.

Definition at line 421 of file tiny.h.

                                                  {
         return std::lower_bound(inner.begin(), inner.end(), key, comp);
     }

◆ lower_bound() [3/4]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::lower_bound ( const T & key ) const

inlinenoexceptinherited

Returns an iterator pointing to the first element that is not less than key.

Definition at line 396 of file tiny.h.

                                                                {
         return std::lower_bound(inner.begin(), inner.end(), key, comp);
     }

◆ lower_bound() [4/4]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::lower_bound ( const T & key )

inlinenoexceptinherited

Returns an iterator pointing to the first element that is not less than key.

Definition at line 388 of file tiny.h.

                                                    {
         return std::lower_bound(inner.begin(), inner.end(), key, comp);
     }

◆ max_size()

size_t tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::max_size

inlinenoexceptinherited

Returns the maximum number of elements the container is able to hold due to system or library implementation limitations.

Definition at line 295 of file tiny.h.

295 {return inner.max_size();}

◆ operator[]() [1/2]

template<typename Key , typename T , typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >>

T& tpie::tiny::map< Key, T, Comp, Alloc >::operator[] ( const Key & key )

inline

Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist.

Definition at line 740 of file tiny.h.

                                     {
         return this->emplace(key, T()).first->second;
     }

References tpie::tiny::set_impl< std::pair< Key, T >, T, bits::PairExtract< Key, T >, std::less< Key >, std::allocator< std::pair< Key, T > >, bits::SingleInsertHelp >::emplace().

◆ operator[]() [2/2]

template<typename Key , typename T , typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >>

T& tpie::tiny::map< Key, T, Comp, Alloc >::operator[] ( Key && key )

inline

Returns a reference to the value that is mapped to a key equivalent to key, performing an insertion if such key does not already exist.

Definition at line 749 of file tiny.h.

                                {
         return this->emplace(std::move(key), T()).first->second;
     }

References tpie::tiny::set_impl< std::pair< Key, T >, T, bits::PairExtract< Key, T >, std::less< Key >, std::allocator< std::pair< Key, T > >, bits::SingleInsertHelp >::emplace().

◆ rbegin() [1/2]

const_reverse_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::rbegin

inlinenoexceptinherited

Returns a reverse iterator to the first element of the reversed container.

Definition at line 239 of file tiny.h.

239 {return inner.rbegin();}

◆ rbegin() [2/2]

reverse_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::rbegin

inlinenoexceptinherited

Returns a reverse iterator to the first element of the reversed container.

Definition at line 234 of file tiny.h.

234 {return inner.rbegin();}

◆ rend() [1/2]

const_reverse_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::rend

inlinenoexceptinherited

Returns a reverse iterator to the element following the last element of the reversed container.

Definition at line 271 of file tiny.h.

271 {return inner.rend();}

◆ rend() [2/2]

reverse_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::rend

inlinenoexceptinherited

Returns a reverse iterator to the element following the last element of the reversed container.

Definition at line 265 of file tiny.h.

265 {return inner.rend();}

◆ reserve()

void tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::reserve ( size_t new_cap )

inlineinherited

Increase the capacity of the container to a value that's greater or equal to new_cap.

If new_cap is greater than the current capacity(), new storage is allocated, otherwise the method does nothing.

Definition at line 664 of file tiny.h.

664 {inner.reserve(new_cap);}

◆ shrink_to_fit()

void tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::shrink_to_fit

inlineinherited

Requests the removal of unused capacity.

Definition at line 669 of file tiny.h.

669 {inner.shrink_to_fit();}

◆ size()

size_t tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::size

inlinenoexceptinherited

Returns the number of elements in the container, i.e.

std::distance(begin(), end())

Definition at line 288 of file tiny.h.

288 {return inner.size();}

◆ swap()

void tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::swap ( set_impl< std::pair< Key, T >, T, bits::PairExtract< Key, T >, std::less< Key >, std::allocator< std::pair< Key, T > >, bits::SingleInsertHelp > & o )

inlineinherited

Exchanges the contents of the container with those of other.

Does not invoke any move, copy, or swap operations on individual elements.

Definition at line 339 of file tiny.h.

                             {
         std::swap(comp, o.comp);
         std::swap(inner, o.inner);
     }

◆ upper_bound() [1/4]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::upper_bound ( const K & key ) const

inlinenoexceptinherited

Returns an iterator pointing to the first element that is greater than key.

Definition at line 448 of file tiny.h.

                                                              {
         return std::upper_bound(inner.begin(), inner.end(), key, comp);
     }

◆ upper_bound() [2/4]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::upper_bound ( const K & key )

inlinenoexceptinherited

Returns an iterator pointing to the first element that is greater than key.

Definition at line 439 of file tiny.h.

                                                  {
         return std::upper_bound(inner.begin(), inner.end(), key, comp);
     }

◆ upper_bound() [3/4]

const_iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::upper_bound ( const T & key ) const

inlinenoexceptinherited

Returns an iterator pointing to the first element that is greater than key.

Definition at line 412 of file tiny.h.

                                                                {
         return std::upper_bound(inner.begin(), inner.end(), key, comp);
     }

◆ upper_bound() [4/4]

iterator tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::upper_bound ( const T & key )

inlinenoexceptinherited

Returns an iterator pointing to the first element that is greater than key.

Definition at line 404 of file tiny.h.

                                                    {
         return std::upper_bound(inner.begin(), inner.end(), key, comp);
     }

◆ value_comp()

value_compare tpie::tiny::set_impl< std::pair< Key, T > , T , bits::PairExtract< Key, T > , std::less< Key > , std::allocator< std::pair< Key, T > > , bits::SingleInsertHelp >::value_comp

inlinenoexceptinherited

Returns a function object that compares objects of type std::map::value_type (key-value pairs) by using key_comp to compare the first components of the pairs.

Definition at line 466 of file tiny.h.

                                               {
         return comp;
     }

The documentation for this class was generated from the following file:

tiny.h

TPIE

Public Types

Public Member Functions

Protected Types

Protected Attributes

Detailed Description

template<typename Key, typename T, typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >> class tpie::tiny::map< Key, T, Comp, Alloc >

Member Function Documentation

◆ at() [1/2]

◆ at() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ clear()

◆ count()

◆ crbegin()

◆ crend()

◆ emplace()

◆ emplace_hint()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ find() [1/2]

◆ find() [2/2]

◆ get_allocator()

◆ insert() [1/6]

◆ insert() [2/6]

◆ insert() [3/6]

◆ insert() [4/6]

◆ insert() [5/6]

◆ insert() [6/6]

◆ key_comp()

◆ lower_bound() [1/4]

◆ lower_bound() [2/4]

◆ lower_bound() [3/4]

◆ lower_bound() [4/4]

◆ max_size()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ reserve()

◆ shrink_to_fit()

◆ size()

◆ swap()

◆ upper_bound() [1/4]

◆ upper_bound() [2/4]

◆ upper_bound() [3/4]

◆ upper_bound() [4/4]

◆ value_comp()

template<typename Key, typename T, typename Comp = std::less<Key>, typename Alloc = std::allocator<std::pair<Key, T> >>
class tpie::tiny::map< Key, T, Comp, Alloc >