momo  3.12
Classes | Public Types | Public Member Functions | Friends | List of all members
momo::stdish::set_adaptor< TTreeSet > Class Template Reference

#include <set.h>

Inheritance diagram for momo::stdish::set_adaptor< TTreeSet >:
momo::stdish::multiset_adaptor< TTreeSet >

Public Types

typedef TreeSet::Key key_type
 
typedef TreeTraits::LessComparer key_compare
 
typedef TreeSet nested_container_type
 
typedef size_t size_type
 
typedef ptrdiff_t difference_type
 
typedef key_type value_type
 
typedef key_compare value_compare
 
typedef std::allocator_traits< typename MemManager::ByteAllocator >::template rebind_alloc< value_type > allocator_type
 
typedef TreeSet::ConstIterator const_iterator
 
typedef TreeSet::Iterator iterator
 
typedef value_type & reference
 
typedef const_iterator::Reference const_reference
 
typedef value_type * pointer
 
typedef const_iterator::Pointer const_pointer
 
typedef std::reverse_iterator< iterator > reverse_iterator
 
typedef std::reverse_iterator< const_iterator > const_reverse_iterator
 
typedef internal::set_node_handle< typename TreeSet::ExtractedItem > node_type
 
typedef internal::insert_return_type< iterator, node_type > insert_return_type
 

Public Member Functions

 set_adaptor ()
 
 set_adaptor (const allocator_type &alloc)
 
 set_adaptor (const key_compare &lessComp, const allocator_type &alloc=allocator_type())
 
template<typename Iterator >
 set_adaptor (Iterator first, Iterator last, const allocator_type &alloc=allocator_type())
 
template<typename Iterator >
 set_adaptor (Iterator first, Iterator last, const key_compare &lessComp, const allocator_type &alloc=allocator_type())
 
 set_adaptor (std::initializer_list< value_type > values, const allocator_type &alloc=allocator_type())
 
 set_adaptor (std::initializer_list< value_type > values, const key_compare &lessComp, const allocator_type &alloc=allocator_type())
 
 set_adaptor (set_adaptor &&right)
 
 set_adaptor (set_adaptor &&right, const allocator_type &alloc)
 
 set_adaptor (const set_adaptor &right)
 
 set_adaptor (const set_adaptor &right, const allocator_type &alloc)
 
 ~set_adaptor ()=default
 
set_adaptor & operator= (set_adaptor &&right) noexcept(momo::internal::ContainerAssignerStd::IsNothrowMoveAssignable< set_adaptor >::value)
 
set_adaptor & operator= (const set_adaptor &right)
 
set_adaptor & operator= (std::initializer_list< value_type > values)
 
void swap (set_adaptor &right) noexcept
 
const nested_container_type & get_nested_container () const noexcept
 
nested_container_type & get_nested_container () noexcept
 
const_iterator begin () const noexcept
 
const_iterator end () const noexcept
 
const_reverse_iterator rbegin () const noexcept
 
const_reverse_iterator rend () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
key_compare key_comp () const
 
value_compare value_comp () const
 
allocator_type get_allocator () const noexcept
 
size_type max_size () const noexcept
 
size_type size () const noexcept
 
MOMO_NODISCARD bool empty () const noexcept
 
void clear () noexcept
 
const_iterator find (const key_type &key) const
 
template<typename KeyArg >
momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, const_iterator > find (const KeyArg &key) const
 
size_type count (const key_type &key) const
 
template<typename KeyArg >
momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, size_type > count (const KeyArg &key) const
 
bool contains (const key_type &key) const
 
template<typename KeyArg >
momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, bool > contains (const KeyArg &key) const
 
const_iterator lower_bound (const key_type &key) const
 
template<typename KeyArg >
momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, const_iterator > lower_bound (const KeyArg &key) const
 
const_iterator upper_bound (const key_type &key) const
 
template<typename KeyArg >
momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, const_iterator > upper_bound (const KeyArg &key) const
 
std::pair< const_iterator, const_iterator > equal_range (const key_type &key) const
 
template<typename KeyArg >
momo::internal::EnableIf< IsValidKeyArg< KeyArg >::value, std::pair< const_iterator, const_iterator > > equal_range (const KeyArg &key) const
 
std::pair< iterator, bool > insert (value_type &&value)
 
iterator insert (const_iterator hint, value_type &&value)
 
std::pair< iterator, bool > insert (const value_type &value)
 
iterator insert (const_iterator hint, const value_type &value)
 
insert_return_type insert (node_type &&node)
 
iterator insert (const_iterator hint, node_type &&node)
 
template<typename Iterator >
void insert (Iterator first, Iterator last)
 
void insert (std::initializer_list< value_type > values)
 
template<typename... ValueArgs>
std::pair< iterator, bool > emplace (ValueArgs &&... valueArgs)
 
template<typename ValueArg >
momo::internal::EnableIf< std::is_same< key_type, typename std::decay< ValueArg >::type >::value, std::pair< iterator, bool > > emplace (ValueArg &&valueArg)
 
template<typename... ValueArgs>
iterator emplace_hint (const_iterator hint, ValueArgs &&... valueArgs)
 
template<typename ValueArg >
momo::internal::EnableIf< std::is_same< key_type, typename std::decay< ValueArg >::type >::value, iterator > emplace_hint (const_iterator hint, ValueArg &&valueArg)
 
iterator erase (const_iterator where)
 
iterator erase (const_iterator first, const_iterator last)
 
size_type erase (const key_type &key)
 
node_type extract (const_iterator where)
 
node_type extract (const key_type &key)
 
template<typename Set >
void merge (Set &&set_adaptor)
 

Friends

void swap (set_adaptor &left, set_adaptor &right) noexcept
 
template<typename ValueFilter >
size_type erase_if (set_adaptor &cont, const ValueFilter &valueFilter)
 
bool operator== (const set_adaptor &left, const set_adaptor &right)
 
bool operator< (const set_adaptor &left, const set_adaptor &right)
 

Member Typedef Documentation

◆ allocator_type

template<typename TTreeSet >
typedef std::allocator_traits<typename MemManager::ByteAllocator>::template rebind_alloc<value_type> momo::stdish::set_adaptor< TTreeSet >::allocator_type

◆ const_iterator

template<typename TTreeSet >
typedef TreeSet::ConstIterator momo::stdish::set_adaptor< TTreeSet >::const_iterator

◆ const_pointer

template<typename TTreeSet >
typedef const_iterator::Pointer momo::stdish::set_adaptor< TTreeSet >::const_pointer

◆ const_reference

template<typename TTreeSet >
typedef const_iterator::Reference momo::stdish::set_adaptor< TTreeSet >::const_reference

◆ const_reverse_iterator

template<typename TTreeSet >
typedef std::reverse_iterator<const_iterator> momo::stdish::set_adaptor< TTreeSet >::const_reverse_iterator

◆ difference_type

template<typename TTreeSet >
typedef ptrdiff_t momo::stdish::set_adaptor< TTreeSet >::difference_type

◆ insert_return_type

template<typename TTreeSet >
typedef internal::insert_return_type<iterator, node_type> momo::stdish::set_adaptor< TTreeSet >::insert_return_type

◆ iterator

template<typename TTreeSet >
typedef TreeSet::Iterator momo::stdish::set_adaptor< TTreeSet >::iterator

◆ key_compare

template<typename TTreeSet >
typedef TreeTraits::LessComparer momo::stdish::set_adaptor< TTreeSet >::key_compare

◆ key_type

template<typename TTreeSet >
typedef TreeSet::Key momo::stdish::set_adaptor< TTreeSet >::key_type

◆ nested_container_type

template<typename TTreeSet >
typedef TreeSet momo::stdish::set_adaptor< TTreeSet >::nested_container_type

◆ node_type

template<typename TTreeSet >
typedef internal::set_node_handle<typename TreeSet::ExtractedItem> momo::stdish::set_adaptor< TTreeSet >::node_type

◆ pointer

template<typename TTreeSet >
typedef value_type* momo::stdish::set_adaptor< TTreeSet >::pointer

◆ reference

template<typename TTreeSet >
typedef value_type& momo::stdish::set_adaptor< TTreeSet >::reference

◆ reverse_iterator

template<typename TTreeSet >
typedef std::reverse_iterator<iterator> momo::stdish::set_adaptor< TTreeSet >::reverse_iterator

◆ size_type

template<typename TTreeSet >
typedef size_t momo::stdish::set_adaptor< TTreeSet >::size_type

◆ value_compare

template<typename TTreeSet >
typedef key_compare momo::stdish::set_adaptor< TTreeSet >::value_compare

◆ value_type

template<typename TTreeSet >
typedef key_type momo::stdish::set_adaptor< TTreeSet >::value_type

Constructor & Destructor Documentation

◆ set_adaptor() [1/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( )
inline

◆ set_adaptor() [2/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( const allocator_type &  alloc)
inlineexplicit

◆ set_adaptor() [3/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( const key_compare &  lessComp,
const allocator_type &  alloc = allocator_type() 
)
inlineexplicit

◆ set_adaptor() [4/11]

template<typename TTreeSet >
template<typename Iterator >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( Iterator  first,
Iterator  last,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ set_adaptor() [5/11]

template<typename TTreeSet >
template<typename Iterator >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( Iterator  first,
Iterator  last,
const key_compare &  lessComp,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ set_adaptor() [6/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( std::initializer_list< value_type >  values,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ set_adaptor() [7/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( std::initializer_list< value_type >  values,
const key_compare &  lessComp,
const allocator_type &  alloc = allocator_type() 
)
inline

◆ set_adaptor() [8/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( set_adaptor< TTreeSet > &&  right)
inline

◆ set_adaptor() [9/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( set_adaptor< TTreeSet > &&  right,
const allocator_type &  alloc 
)
inline

◆ set_adaptor() [10/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( const set_adaptor< TTreeSet > &  right)
inline

◆ set_adaptor() [11/11]

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::set_adaptor ( const set_adaptor< TTreeSet > &  right,
const allocator_type &  alloc 
)
inline

◆ ~set_adaptor()

template<typename TTreeSet >
momo::stdish::set_adaptor< TTreeSet >::~set_adaptor ( )
default

Member Function Documentation

◆ begin()

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::begin ( ) const
inlinenoexcept

◆ cbegin()

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::cend ( ) const
inlinenoexcept

◆ clear()

template<typename TTreeSet >
void momo::stdish::set_adaptor< TTreeSet >::clear ( )
inlinenoexcept

◆ contains() [1/2]

template<typename TTreeSet >
bool momo::stdish::set_adaptor< TTreeSet >::contains ( const key_type &  key) const
inline

◆ contains() [2/2]

template<typename TTreeSet >
template<typename KeyArg >
momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, bool> momo::stdish::set_adaptor< TTreeSet >::contains ( const KeyArg &  key) const
inline

◆ count() [1/2]

template<typename TTreeSet >
size_type momo::stdish::set_adaptor< TTreeSet >::count ( const key_type &  key) const
inline

◆ count() [2/2]

template<typename TTreeSet >
template<typename KeyArg >
momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, size_type> momo::stdish::set_adaptor< TTreeSet >::count ( const KeyArg &  key) const
inline

◆ crbegin()

template<typename TTreeSet >
const_reverse_iterator momo::stdish::set_adaptor< TTreeSet >::crbegin ( ) const
inlinenoexcept

◆ crend()

template<typename TTreeSet >
const_reverse_iterator momo::stdish::set_adaptor< TTreeSet >::crend ( ) const
inlinenoexcept

◆ emplace() [1/2]

template<typename TTreeSet >
template<typename ValueArg >
momo::internal::EnableIf<std::is_same<key_type, typename std::decay<ValueArg>::type>::value, std::pair<iterator, bool> > momo::stdish::set_adaptor< TTreeSet >::emplace ( ValueArg &&  valueArg)
inline

◆ emplace() [2/2]

template<typename TTreeSet >
template<typename... ValueArgs>
std::pair<iterator, bool> momo::stdish::set_adaptor< TTreeSet >::emplace ( ValueArgs &&...  valueArgs)
inline

◆ emplace_hint() [1/2]

template<typename TTreeSet >
template<typename ValueArg >
momo::internal::EnableIf<std::is_same<key_type, typename std::decay<ValueArg>::type>::value, iterator> momo::stdish::set_adaptor< TTreeSet >::emplace_hint ( const_iterator  hint,
ValueArg &&  valueArg 
)
inline

◆ emplace_hint() [2/2]

template<typename TTreeSet >
template<typename... ValueArgs>
iterator momo::stdish::set_adaptor< TTreeSet >::emplace_hint ( const_iterator  hint,
ValueArgs &&...  valueArgs 
)
inline

◆ empty()

template<typename TTreeSet >
MOMO_NODISCARD bool momo::stdish::set_adaptor< TTreeSet >::empty ( ) const
inlinenoexcept

◆ end()

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::end ( ) const
inlinenoexcept

◆ equal_range() [1/2]

template<typename TTreeSet >
std::pair<const_iterator, const_iterator> momo::stdish::set_adaptor< TTreeSet >::equal_range ( const key_type &  key) const
inline

◆ equal_range() [2/2]

template<typename TTreeSet >
template<typename KeyArg >
momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, std::pair<const_iterator, const_iterator> > momo::stdish::set_adaptor< TTreeSet >::equal_range ( const KeyArg &  key) const
inline

◆ erase() [1/3]

template<typename TTreeSet >
size_type momo::stdish::set_adaptor< TTreeSet >::erase ( const key_type &  key)
inline

◆ erase() [2/3]

template<typename TTreeSet >
iterator momo::stdish::set_adaptor< TTreeSet >::erase ( const_iterator  first,
const_iterator  last 
)
inline

◆ erase() [3/3]

template<typename TTreeSet >
iterator momo::stdish::set_adaptor< TTreeSet >::erase ( const_iterator  where)
inline

◆ extract() [1/2]

template<typename TTreeSet >
node_type momo::stdish::set_adaptor< TTreeSet >::extract ( const key_type &  key)
inline

◆ extract() [2/2]

template<typename TTreeSet >
node_type momo::stdish::set_adaptor< TTreeSet >::extract ( const_iterator  where)
inline

◆ find() [1/2]

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::find ( const key_type &  key) const
inline

◆ find() [2/2]

template<typename TTreeSet >
template<typename KeyArg >
momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, const_iterator> momo::stdish::set_adaptor< TTreeSet >::find ( const KeyArg &  key) const
inline

◆ get_allocator()

template<typename TTreeSet >
allocator_type momo::stdish::set_adaptor< TTreeSet >::get_allocator ( ) const
inlinenoexcept

◆ get_nested_container() [1/2]

template<typename TTreeSet >
const nested_container_type& momo::stdish::set_adaptor< TTreeSet >::get_nested_container ( ) const
inlinenoexcept

◆ get_nested_container() [2/2]

template<typename TTreeSet >
nested_container_type& momo::stdish::set_adaptor< TTreeSet >::get_nested_container ( )
inlinenoexcept

◆ insert() [1/8]

template<typename TTreeSet >
std::pair<iterator, bool> momo::stdish::set_adaptor< TTreeSet >::insert ( const value_type &  value)
inline

◆ insert() [2/8]

template<typename TTreeSet >
iterator momo::stdish::set_adaptor< TTreeSet >::insert ( const_iterator  hint,
const value_type &  value 
)
inline

◆ insert() [3/8]

template<typename TTreeSet >
iterator momo::stdish::set_adaptor< TTreeSet >::insert ( const_iterator  hint,
node_type &&  node 
)
inline

◆ insert() [4/8]

template<typename TTreeSet >
iterator momo::stdish::set_adaptor< TTreeSet >::insert ( const_iterator  hint,
value_type &&  value 
)
inline

◆ insert() [5/8]

template<typename TTreeSet >
template<typename Iterator >
void momo::stdish::set_adaptor< TTreeSet >::insert ( Iterator  first,
Iterator  last 
)
inline

◆ insert() [6/8]

template<typename TTreeSet >
insert_return_type momo::stdish::set_adaptor< TTreeSet >::insert ( node_type &&  node)
inline

◆ insert() [7/8]

template<typename TTreeSet >
void momo::stdish::set_adaptor< TTreeSet >::insert ( std::initializer_list< value_type >  values)
inline

◆ insert() [8/8]

template<typename TTreeSet >
std::pair<iterator, bool> momo::stdish::set_adaptor< TTreeSet >::insert ( value_type &&  value)
inline

◆ key_comp()

template<typename TTreeSet >
key_compare momo::stdish::set_adaptor< TTreeSet >::key_comp ( ) const
inline

◆ lower_bound() [1/2]

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::lower_bound ( const key_type &  key) const
inline

◆ lower_bound() [2/2]

template<typename TTreeSet >
template<typename KeyArg >
momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, const_iterator> momo::stdish::set_adaptor< TTreeSet >::lower_bound ( const KeyArg &  key) const
inline

◆ max_size()

template<typename TTreeSet >
size_type momo::stdish::set_adaptor< TTreeSet >::max_size ( ) const
inlinenoexcept

◆ merge()

template<typename TTreeSet >
template<typename Set >
void momo::stdish::set_adaptor< TTreeSet >::merge ( Set &&  set_adaptor)
inline

◆ operator=() [1/3]

template<typename TTreeSet >
set_adaptor& momo::stdish::set_adaptor< TTreeSet >::operator= ( const set_adaptor< TTreeSet > &  right)
inline

◆ operator=() [2/3]

template<typename TTreeSet >
set_adaptor& momo::stdish::set_adaptor< TTreeSet >::operator= ( set_adaptor< TTreeSet > &&  right)
inlinenoexcept

◆ operator=() [3/3]

template<typename TTreeSet >
set_adaptor& momo::stdish::set_adaptor< TTreeSet >::operator= ( std::initializer_list< value_type >  values)
inline

◆ rbegin()

template<typename TTreeSet >
const_reverse_iterator momo::stdish::set_adaptor< TTreeSet >::rbegin ( ) const
inlinenoexcept

◆ rend()

template<typename TTreeSet >
const_reverse_iterator momo::stdish::set_adaptor< TTreeSet >::rend ( ) const
inlinenoexcept

◆ size()

template<typename TTreeSet >
size_type momo::stdish::set_adaptor< TTreeSet >::size ( ) const
inlinenoexcept

◆ swap()

template<typename TTreeSet >
void momo::stdish::set_adaptor< TTreeSet >::swap ( set_adaptor< TTreeSet > &  right)
inlinenoexcept

◆ upper_bound() [1/2]

template<typename TTreeSet >
const_iterator momo::stdish::set_adaptor< TTreeSet >::upper_bound ( const key_type &  key) const
inline

◆ upper_bound() [2/2]

template<typename TTreeSet >
template<typename KeyArg >
momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value, const_iterator> momo::stdish::set_adaptor< TTreeSet >::upper_bound ( const KeyArg &  key) const
inline

◆ value_comp()

template<typename TTreeSet >
value_compare momo::stdish::set_adaptor< TTreeSet >::value_comp ( ) const
inline

Friends And Related Function Documentation

◆ erase_if

template<typename TTreeSet >
template<typename ValueFilter >
size_type erase_if ( set_adaptor< TTreeSet > &  cont,
const ValueFilter &  valueFilter 
)
friend

◆ operator<

template<typename TTreeSet >
bool operator< ( const set_adaptor< TTreeSet > &  left,
const set_adaptor< TTreeSet > &  right 
)
friend

◆ operator==

template<typename TTreeSet >
bool operator== ( const set_adaptor< TTreeSet > &  left,
const set_adaptor< TTreeSet > &  right 
)
friend

◆ swap

template<typename TTreeSet >
void swap ( set_adaptor< TTreeSet > &  left,
set_adaptor< TTreeSet > &  right 
)
friend
The documentation for this class was generated from the following file: