Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant > Struct Template Reference

Base type for iterators. 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 = typename SequencialMap::value_type
using	pointer = typename std::conditional< constant, const value_type *, value_type * >::type
using	reference = typename std::conditional< constant, const value_type &, value_type & >::type

Public Member Functions
	iterator_base ()=default
template<bool OtherConstant>
	iterator_base (const iterator_base< OtherConstant > &other)
reference	operator* () const
pointer	operator-> () const
template<bool OtherConstant>
iterator_base &	operator= (const iterator_base< OtherConstant > &other)
template<bool otherConstant>
bool	operator== (const iterator_base< otherConstant > &other) const
template<bool otherConstant>
bool	operator!= (const iterator_base< otherConstant > &other) const
template<bool otherConstant>
bool	operator< (const iterator_base< otherConstant > &other) const
template<bool otherConstant>
bool	operator<= (const iterator_base< otherConstant > &other) const
template<bool otherConstant>
bool	operator> (const iterator_base< otherConstant > &other) const
template<bool otherConstant>
bool	operator>= (const iterator_base< otherConstant > &other) const
iterator_base &	operator++ ()
iterator_base	operator++ (int)
iterator_base &	operator-- ()
iterator_base	operator-- (int)
iterator_base &	operator+= (difference_type j)
iterator_base &	operator-= (difference_type j)
iterator_base	operator+ (difference_type j) const
iterator_base	operator- (difference_type j) const
difference_type	operator- (iterator_base j) const

Protected Member Functions
	iterator_base (const node_type *node)

Protected Attributes
node_type *	n = nullptr

Friends
class	SequencialMap
struct	iterator_base<!constant >
iterator_base	operator+ (difference_type j, iterator_base &it)

Detailed Description

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

Base type for iterators.

Template Parameters

constant

Whether the iterator is mutable or constant.

Member Typedef Documentation

iterator_category

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

template<bool constant>

using Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

using Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

using Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

using Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::value_type = typename SequencialMap::value_type

pointer

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

template<bool constant>

using Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::pointer = typename std::conditional<constant, const value_type*, value_type*>::type

reference

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

template<bool constant>

using Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::reference = typename std::conditional<constant, const value_type&, value_type&>::type

Constructor & Destructor Documentation

iterator_base() [1/3]

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

template<bool constant>

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

inlinedefault

iterator_base() [2/3]

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

template<bool constant>

template<bool OtherConstant>

Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::iterator_base ( const iterator_base< OtherConstant > &  other )

inline

iterator_base() [3/3]

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

template<bool constant>

Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::iterator_base ( const node_type *  node )

inlineexplicitprotected

Member Function Documentation

operator*()

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

template<bool constant>

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

inline

operator->()

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

template<bool constant>

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

inline

operator=()

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

template<bool constant>

template<bool OtherConstant>

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

inline

operator==()

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

template<bool constant>

template<bool otherConstant>

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

inline

operator!=()

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

template<bool constant>

template<bool otherConstant>

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

inline

operator<()

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

template<bool constant>

template<bool otherConstant>

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

inline

operator<=()

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

template<bool constant>

template<bool otherConstant>

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

inline

operator>()

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

template<bool constant>

template<bool otherConstant>

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

inline

operator>=()

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

template<bool constant>

template<bool otherConstant>

bool Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::operator>= ( const iterator_base< otherConstant > &  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>>>

template<bool constant>

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

inline

operator++() [2/2]

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

template<bool constant>

iterator_base Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

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

inline

operator--() [2/2]

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

template<bool constant>

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

inline

operator+=()

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

template<bool constant>

iterator_base & Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

iterator_base & Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

iterator_base Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

iterator_base Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::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>>>

template<bool constant>

difference_type Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::operator- ( iterator_base< constant >  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>>>

template<bool constant>

friend class SequencialMap

friend

iterator_base<!constant >

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

template<bool constant>

friend struct iterator_base<!constant >

friend

operator+

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

template<bool constant>

iterator_base operator+ ( difference_type  j, iterator_base< constant > &  it  )

friend

Member Data Documentation

n

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

template<bool constant>

node_type* Container::SequencialMap< Key, T, Compare, Allocator >::iterator_base< constant >::n = nullptr

mutableprotected

---

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

• include/Utilities/Containers/SequencialMap.hpp