Cpp Utilities: Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator Struct Reference

Cpp Utilities 1.2.3

Iterator to traverse keys. More...

#include <SequencialMap.hpp>

Public Types
using	iterator_category = std::random_access_iterator_tag

using	difference_type = typename SequencialMap::difference_type

using	node_type = typename SequencialMap::vector_type::value_type

using	value_type = Key

using	reference = const value_type &

using	pointer = const value_type *

Public Member Functions
	key_iterator ()=default

	key_iterator (const key_iterator &other)

reference	operator* () const

pointer	operator-> () const

key_iterator &	operator= (const key_iterator &other)

bool	operator== (const key_iterator &other) const

bool	operator!= (const key_iterator &other) const

bool	operator< (const key_iterator &other) const

bool	operator<= (const key_iterator &other) const

bool	operator> (const key_iterator &other) const

bool	operator>= (const key_iterator &other) const

key_iterator &	operator++ ()

key_iterator	operator++ (int)

key_iterator &	operator-- ()

key_iterator	operator-- (int)

key_iterator &	operator+= (difference_type j)

key_iterator &	operator-= (difference_type j)

key_iterator	operator+ (difference_type j) const

key_iterator	operator- (difference_type j) const

difference_type	operator- (key_iterator j) const

Friends
class	SequencialMap

key_iterator	operator+ (difference_type j, key_iterator &it)

Detailed Description

template<typename Key, typename T, typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>
struct Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator

Iterator to traverse keys.

Member Typedef Documentation

◆ iterator_category

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

using Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::iterator_category = std::random_access_iterator_tag

◆ difference_type

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

using Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::difference_type = typename SequencialMap::difference_type

◆ node_type

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

using Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::node_type = typename SequencialMap::vector_type::value_type

◆ value_type

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

using Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::value_type = Key

◆ reference

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

using Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::reference = const value_type&

◆ pointer

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

using Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::pointer = const value_type*

Constructor & Destructor Documentation

◆ key_iterator() [1/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::key_iterator ( )

inlinedefault

◆ key_iterator() [2/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::key_iterator ( const key_iterator & other )

inline

Member Function Documentation

◆ operator*()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

reference Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator* ( ) const

inline

◆ operator->()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

pointer Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator-> ( ) const

inline

◆ operator=()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator & Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator= ( const key_iterator & other )

inline

◆ operator==()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

bool Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator== ( const key_iterator & other ) const

inline

◆ operator!=()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

bool Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator!= ( const key_iterator & other ) const

inline

◆ operator<()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

bool Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator< ( const key_iterator & other ) const

inline

◆ operator<=()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

bool Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator<= ( const key_iterator & other ) const

inline

◆ operator>()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

bool Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator> ( const key_iterator & other ) const

inline

◆ operator>=()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

bool Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator>= ( const key_iterator & other ) const

inline

◆ operator++() [1/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator & Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator++ ( )

inline

◆ operator++() [2/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator++ ( int )

inline

◆ operator--() [1/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator & Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator-- ( )

inline

◆ operator--() [2/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator-- ( int )

inline

◆ operator+=()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator & Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator+= ( difference_type j )

inline

◆ operator-=()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator & Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator-= ( difference_type j )

inline

◆ operator+()

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator+ ( difference_type j ) const

inline

◆ operator-() [1/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator- ( difference_type j ) const

inline

◆ operator-() [2/2]

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

difference_type Container::SequencialMap< Key, T, Compare, Allocator >::key_iterator::operator- ( key_iterator j ) const

inline

Friends And Related Function Documentation

◆ SequencialMap

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

friend class SequencialMap

friend

◆ operator+

template<typename Key , typename T , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>

key_iterator operator+	(	difference_type	j,
		key_iterator &	it
	)

friend

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

include/Utilities/Containers/SequencialMap.hpp