ManaPlus
Data Structures | Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes
mse::msevector< _Ty, _A > Class Template Reference

#include <msemsevector.h>

Inheritance diagram for mse::msevector< _Ty, _A >:

Data Structures

class  cipointer
 
class  ipointer
 
class  mm_const_iterator_handle_type
 
class  mm_const_iterator_type
 
class  mm_iterator_handle_type
 
class  mm_iterator_set_type
 
class  mm_iterator_type
 
class  random_access_const_iterator_base
 
class  random_access_iterator_base
 
class  ss_const_iterator_type
 
class  ss_iterator_type
 

Public Types

typedef std::vector< _Ty, _A > base_class
 
typedef msevector< _Ty, _A > _Myt
 
typedef base_class::value_type value_type
 
typedef msev_size_t size_type
 
typedef msev_int difference_type
 
typedef base_class::pointer pointer
 
typedef base_class::const_pointer const_pointer
 
typedef base_class::reference reference
 
typedef base_class::const_reference const_reference
 
typedef base_class::const_iterator _It
 
typedef std::reverse_iterator< ss_iterator_type > ss_reverse_iterator_type
 
typedef std::reverse_iterator< ss_const_iterator_type > ss_const_reverse_iterator_type
 

Public Member Functions

 msevector (const _A &_Al=_A())
 
 msevector (size_type _N)
 
 msevector (size_type _N, const _Ty &_V, const _A &_Al=_A())
 
 msevector (base_class &&_X)
 
 msevector (const base_class &_X)
 
 msevector (_Myt &&_X)
 
 msevector (const _Myt &_X)
 
 msevector (_It _F, _It _L, const _A &_Al=_A())
 
 msevector (const _Ty *_F, const _Ty *_L, const _A &_Al=_A())
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
 msevector (_Iter _First, _Iter _Last)
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
 msevector (_Iter _First, _Iter _Last, const _A &_Al)
 
_Myt & operator= (const base_class &_X)
 
_Myt & operator= (_Myt &&_X)
 
_Myt & operator= (const _Myt &_X)
 
void reserve (size_type _Count)
 
void shrink_to_fit ()
 
void resize (size_type _N, const _Ty &_X=_Ty())
 
base_class::const_reference operator[] (size_type _P) const
 
base_class::reference operator[] (size_type _P)
 
base_class::reference front ()
 
base_class::const_reference front () const
 
base_class::reference back ()
 
base_class::const_reference back () const
 
void push_back (_Ty &&_X)
 
void push_back (const _Ty &_X)
 
void pop_back ()
 
void assign (_It _F, _It _L)
 
template<class _Iter >
void assign (_Iter _First, _Iter _Last)
 
void assign (size_type _N, const _Ty &_X=_Ty())
 
base_class::iterator insert (typename base_class::const_iterator _P, _Ty &&_X)
 
base_class::iterator insert (typename base_class::const_iterator _P, const _Ty &_X=_Ty())
 
base_class::iterator insert (typename base_class::const_iterator _P, size_type _M, const _Ty &_X)
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
base_class::iterator insert (typename base_class::const_iterator _Where, _Iter _First, _Iter _Last)
 
template<class ... _Valty>
void emplace_back (_Valty &&..._Val)
 
template<class ... _Valty>
base_class::iterator emplace (typename base_class::const_iterator _Where, _Valty &&..._Val)
 
base_class::iterator erase (typename base_class::const_iterator _P)
 
base_class::iterator erase (typename base_class::const_iterator _F, typename base_class::const_iterator _L)
 
void clear ()
 
void swap (base_class &_X)
 
void swap (_Myt &_X)
 
 msevector (::std::initializer_list< typename base_class::value_type > _Ilist, const _A &_Al=_A())
 
_Myt & operator= (::std::initializer_list< typename base_class::value_type > _Ilist)
 
void assign (::std::initializer_list< typename base_class::value_type > _Ilist)
 
base_class::iterator insert (typename base_class::const_iterator _Where, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
mm_const_iterator_type & const_item_pointer (mm_const_iterator_handle_type handle) const
 
mm_iterator_type & item_pointer (mm_iterator_handle_type handle)
 
ipointer ibegin ()
 
cipointer ibegin () const
 
ipointer iend ()
 
cipointer iend () const
 
cipointer cibegin () const
 
cipointer ciend () const
 
 msevector (const cipointer &start, const cipointer &end, const _A &_Al=_A())
 
void assign (const mm_const_iterator_type &start, const mm_const_iterator_type &end)
 
void assign_inclusive (const mm_const_iterator_type &first, const mm_const_iterator_type &last)
 
void assign (const cipointer &start, const cipointer &end)
 
void assign_inclusive (const cipointer &first, const cipointer &last)
 
void insert_before (const mm_const_iterator_type &pos, size_type _M, const _Ty &_X)
 
void insert_before (const mm_const_iterator_type &pos, _Ty &&_X)
 
void insert_before (const mm_const_iterator_type &pos, const _Ty &_X=_Ty())
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
void insert_before (const mm_const_iterator_type &pos, const _Iter &start, const _Iter &end)
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
void insert_before_inclusive (const mm_const_iterator_type &pos, const _Iter &first, const _Iter &last)
 
void insert_before (const mm_const_iterator_type &pos, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
ipointer insert_before (const cipointer &pos, size_type _M, const _Ty &_X)
 
ipointer insert_before (const cipointer &pos, _Ty &&_X)
 
ipointer insert_before (const cipointer &pos, const _Ty &_X=_Ty())
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ipointer insert_before (const cipointer &pos, const _Iter &start, const _Iter &end)
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ipointer insert_before_inclusive (const cipointer &pos, const _Iter &first, const _Iter &last)
 
ipointer insert_before (const cipointer &pos, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
void insert_before (msev_size_t pos, _Ty &&_X)
 
void insert_before (msev_size_t pos, const _Ty &_X=_Ty())
 
void insert_before (msev_size_t pos, size_t _M, const _Ty &_X)
 
void insert_before (msev_size_t pos, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
ipointer insert (const cipointer &pos, size_type _M, const _Ty &_X)
 
ipointer insert (const cipointer &pos, _Ty &&_X)
 
ipointer insert (const cipointer &pos, const _Ty &_X=_Ty())
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ipointer insert (const cipointer &pos, const _Iter &start, const _Iter &end)
 
ipointer insert (const cipointer &pos, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
template<class ... _Valty>
void emplace (const mm_const_iterator_type &pos, _Valty &&..._Val)
 
template<class ... _Valty>
ipointer emplace (const cipointer &pos, _Valty &&..._Val)
 
void erase (const mm_const_iterator_type &pos)
 
void erase (const mm_const_iterator_type &start, const mm_const_iterator_type &end)
 
void erase_inclusive (const mm_const_iterator_type &first, const mm_const_iterator_type &last)
 
ipointer erase (const cipointer &pos)
 
ipointer erase (const cipointer &start, const cipointer &end)
 
ipointer erase_inclusive (const cipointer &first, const cipointer &last)
 
void erase_previous_item (const mm_const_iterator_type &pos)
 
ipointer erase_previous_item (const cipointer &pos)
 
ss_iterator_type ss_begin ()
 
ss_const_iterator_type ss_begin () const
 
ss_iterator_type ss_end ()
 
ss_const_iterator_type ss_end () const
 
ss_const_iterator_type ss_cbegin () const
 
ss_const_iterator_type ss_cend () const
 
ss_const_reverse_iterator_type ss_crbegin () const
 
ss_const_reverse_iterator_type ss_crend () const
 
ss_reverse_iterator_type ss_rbegin ()
 
ss_const_reverse_iterator_type ss_rbegin () const
 
ss_reverse_iterator_type ss_rend ()
 
ss_const_reverse_iterator_type ss_rend () const
 
 msevector (const ss_const_iterator_type &start, const ss_const_iterator_type &end, const _A &_Al=_A())
 
void assign (const ss_const_iterator_type &start, const ss_const_iterator_type &end)
 
void assign_inclusive (const ss_const_iterator_type &first, const ss_const_iterator_type &last)
 
ss_iterator_type insert_before (const ss_const_iterator_type &pos, size_type _M, const _Ty &_X)
 
ss_iterator_type insert_before (const ss_const_iterator_type &pos, _Ty &&_X)
 
ss_iterator_type insert_before (const ss_const_iterator_type &pos, const _Ty &_X=_Ty())
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ss_iterator_type insert_before (const ss_const_iterator_type &pos, const _Iter &start, const _Iter &end)
 
ss_iterator_type insert_before (const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end)
 
ss_iterator_type insert_before (const ss_const_iterator_type &pos, const _Ty *start, const _Ty *end)
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ss_iterator_type insert_before_inclusive (const ss_iterator_type &pos, const _Iter &first, const _Iter &last)
 
ss_iterator_type insert_before (const ss_const_iterator_type &pos, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
ss_iterator_type insert (const ss_const_iterator_type &pos, size_type _M, const _Ty &_X)
 
ss_iterator_type insert (const ss_const_iterator_type &pos, _Ty &&_X)
 
ss_iterator_type insert (const ss_const_iterator_type &pos, const _Ty &_X=_Ty())
 
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ss_iterator_type insert (const ss_const_iterator_type &pos, const _Iter &start, const _Iter &end)
 
ss_iterator_type insert (const ss_const_iterator_type &pos, const _Ty *start, const _Ty *&end)
 
ss_iterator_type insert (const ss_const_iterator_type &pos, ::std::initializer_list< typename base_class::value_type > _Ilist)
 
template<class ... _Valty>
ss_iterator_type emplace (const ss_const_iterator_type &pos, _Valty &&..._Val)
 
ss_iterator_type erase (const ss_const_iterator_type &pos)
 
ss_iterator_type erase (const ss_const_iterator_type &start, const ss_const_iterator_type &end)
 
ss_iterator_type erase_inclusive (const ss_const_iterator_type &first, const ss_const_iterator_type &last)
 
void erase_previous_item (const ss_const_iterator_type &pos)
 

Private Types

typedef std::size_t CHashKey1
 

Private Member Functions

mm_const_iterator_handle_type allocate_new_const_item_pointer () const
 
void release_const_item_pointer (mm_const_iterator_handle_type handle) const
 
void release_all_const_item_pointers () const
 
mm_iterator_handle_type allocate_new_item_pointer () const
 
void release_item_pointer (mm_iterator_handle_type handle) const
 
void release_all_item_pointers () const
 

Private Attributes

mm_iterator_set_type m_mmitset
 

Detailed Description

template<class _Ty, class _A = std::allocator<_Ty>>
class mse::msevector< _Ty, _A >

Definition at line 150 of file msemsevector.h.

Member Typedef Documentation

◆ _It

template<class _Ty , class _A = std::allocator<_Ty>>
typedef base_class::const_iterator mse::msevector< _Ty, _A >::_It

Definition at line 181 of file msemsevector.h.

◆ _Myt

template<class _Ty , class _A = std::allocator<_Ty>>
typedef msevector<_Ty, _A> mse::msevector< _Ty, _A >::_Myt

Definition at line 153 of file msemsevector.h.

◆ base_class

template<class _Ty , class _A = std::allocator<_Ty>>
typedef std::vector<_Ty, _A> mse::msevector< _Ty, _A >::base_class

Definition at line 152 of file msemsevector.h.

◆ CHashKey1

template<class _Ty , class _A = std::allocator<_Ty>>
typedef std::size_t mse::msevector< _Ty, _A >::CHashKey1
private

Definition at line 1119 of file msemsevector.h.

◆ const_pointer

template<class _Ty , class _A = std::allocator<_Ty>>
typedef base_class::const_pointer mse::msevector< _Ty, _A >::const_pointer

Definition at line 161 of file msemsevector.h.

◆ const_reference

template<class _Ty , class _A = std::allocator<_Ty>>
typedef base_class::const_reference mse::msevector< _Ty, _A >::const_reference

Definition at line 163 of file msemsevector.h.

◆ difference_type

template<class _Ty , class _A = std::allocator<_Ty>>
typedef msev_int mse::msevector< _Ty, _A >::difference_type

Definition at line 159 of file msemsevector.h.

◆ pointer

template<class _Ty , class _A = std::allocator<_Ty>>
typedef base_class::pointer mse::msevector< _Ty, _A >::pointer

Definition at line 160 of file msemsevector.h.

◆ reference

template<class _Ty , class _A = std::allocator<_Ty>>
typedef base_class::reference mse::msevector< _Ty, _A >::reference

Definition at line 162 of file msemsevector.h.

◆ size_type

template<class _Ty , class _A = std::allocator<_Ty>>
typedef msev_size_t mse::msevector< _Ty, _A >::size_type

Definition at line 157 of file msemsevector.h.

◆ ss_const_reverse_iterator_type

template<class _Ty , class _A = std::allocator<_Ty>>
typedef std::reverse_iterator<ss_const_iterator_type> mse::msevector< _Ty, _A >::ss_const_reverse_iterator_type

Definition at line 2197 of file msemsevector.h.

◆ ss_reverse_iterator_type

template<class _Ty , class _A = std::allocator<_Ty>>
typedef std::reverse_iterator<ss_iterator_type> mse::msevector< _Ty, _A >::ss_reverse_iterator_type

Definition at line 2196 of file msemsevector.h.

◆ value_type

template<class _Ty , class _A = std::allocator<_Ty>>
typedef base_class::value_type mse::msevector< _Ty, _A >::value_type

Definition at line 155 of file msemsevector.h.

Constructor & Destructor Documentation

◆ msevector() [1/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( const _A &  _Al = _A())
inlineexplicit

Definition at line 165 of file msemsevector.h.

166  : base_class(_Al), m_mmitset(*this) {
167  /*m_debug_size = size();*/
168  }
mse::msevector::base_class
std::vector< _Ty, _A > base_class
Definition: msemsevector.h:152
mse::msevector::m_mmitset
mm_iterator_set_type m_mmitset
Definition: msemsevector.h:1427

◆ msevector() [2/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( size_type  _N)
inlineexplicit

Definition at line 169 of file msemsevector.h.

170  : base_class(msev_as_a_size_t(_N)), m_mmitset(*this) {
171  /*m_debug_size = size();*/
172  }
mse::msev_as_a_size_t
size_t msev_as_a_size_t
Definition: msemsevector.h:64

◆ msevector() [3/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( size_type  _N,
const _Ty &  _V,
const _A &  _Al = _A() 
)
inlineexplicit

Definition at line 173 of file msemsevector.h.

174  : base_class(msev_as_a_size_t(_N), _V, _Al), m_mmitset(*this) {
175  /*m_debug_size = size();*/
176  }

◆ msevector() [4/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( base_class &&  _X)
inline

Definition at line 177 of file msemsevector.h.

177 : base_class(std::move(_X)), m_mmitset(*this) { /*m_debug_size = size();*/ }
Actions::move
bool move(InputEvent &event)
Definition: commands.cpp:44

◆ msevector() [5/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( const base_class &  _X)
inline

Definition at line 178 of file msemsevector.h.

178 : base_class(_X), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [6/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( _Myt &&  _X)
inline

Definition at line 179 of file msemsevector.h.

179 : base_class(std::move(_X)), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [7/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( const _Myt &  _X)
inline

Definition at line 180 of file msemsevector.h.

180 : base_class(_X), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [8/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( _It  _F,
_It  _L,
const _A &  _Al = _A() 
)
inline

Definition at line 183 of file msemsevector.h.

183 : base_class(_F, _L, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [9/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( const _Ty *  _F,
const _Ty *  _L,
const _A &  _Al = _A() 
)
inline

Definition at line 184 of file msemsevector.h.

184 : base_class(_F, _L, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [10/14]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
mse::msevector< _Ty, _A >::msevector ( _Iter  _First,
_Iter  _Last 
)
inline

Definition at line 188 of file msemsevector.h.

188 : base_class(_First, _Last), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [11/14]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
mse::msevector< _Ty, _A >::msevector ( _Iter  _First,
_Iter  _Last,
const _A &  _Al 
)
inline

Definition at line 193 of file msemsevector.h.

193 : base_class(_First, _Last, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }

◆ msevector() [12/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( ::std::initializer_list< typename base_class::value_type >  _Ilist,
const _A &  _Al = _A() 
)
inline

Definition at line 652 of file msemsevector.h.

654  : base_class(_Ilist, _Al), m_mmitset(*this) { // construct from initializer_list
655  /*m_debug_size = size();*/
656  }

◆ msevector() [13/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( const cipointer &  start,
const cipointer &  end,
const _A &  _Al = _A() 
)
inline

Definition at line 1622 of file msemsevector.h.

1623  : base_class(_Al), m_mmitset(*this) {
1624  /*m_debug_size = size();*/
1625  assign(start, end);
1626  }
mse::msevector::assign
void assign(_It _F, _It _L)
Definition: msemsevector.h:335
anonymous_namespace{stringutils.cpp}::start
unsigned int start
Definition: stringutils.cpp:228

References mse::msevector< _Ty, _A >::assign(), and anonymous_namespace{stringutils.cpp}::start.

◆ msevector() [14/14]

template<class _Ty , class _A = std::allocator<_Ty>>
mse::msevector< _Ty, _A >::msevector ( const ss_const_iterator_type &  start,
const ss_const_iterator_type &  end,
const _A &  _Al = _A() 
)
inline

Definition at line 2271 of file msemsevector.h.

2272  : base_class(_Al), m_mmitset(*this) {
2273  /*m_debug_size = size();*/
2274  assign(start, end);
2275  }

References mse::msevector< _Ty, _A >::assign(), and anonymous_namespace{stringutils.cpp}::start.

Member Function Documentation

◆ allocate_new_const_item_pointer()

template<class _Ty , class _A = std::allocator<_Ty>>
mm_const_iterator_handle_type mse::msevector< _Ty, _A >::allocate_new_const_item_pointer ( ) const
inlineprivate

Definition at line 1438 of file msemsevector.h.

1438 { return m_mmitset.allocate_new_const_item_pointer(); }
mse::msevector::mm_iterator_set_type::allocate_new_const_item_pointer
mm_const_iterator_handle_type allocate_new_const_item_pointer()
Definition: msemsevector.h:1246

References mse::msevector< _Ty, _A >::mm_iterator_set_type::allocate_new_const_item_pointer(), and mse::msevector< _Ty, _A >::m_mmitset.

Referenced by mse::msevector< _Ty, _A >::cipointer::cipointer().

◆ allocate_new_item_pointer()

template<class _Ty , class _A = std::allocator<_Ty>>
mm_iterator_handle_type mse::msevector< _Ty, _A >::allocate_new_item_pointer ( ) const
inlineprivate

Definition at line 1441 of file msemsevector.h.

1441 { return m_mmitset.allocate_new_item_pointer(); }
mse::msevector::mm_iterator_set_type::allocate_new_item_pointer
mm_iterator_handle_type allocate_new_item_pointer()
Definition: msemsevector.h:1306

References mse::msevector< _Ty, _A >::mm_iterator_set_type::allocate_new_item_pointer(), and mse::msevector< _Ty, _A >::m_mmitset.

Referenced by mse::msevector< _Ty, _A >::ipointer::ipointer().

◆ assign() [1/7]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign ( ::std::initializer_list< typename base_class::value_type >  _Ilist)
inline

Definition at line 662 of file msemsevector.h.

662  { // assign initializer_list
663  base_class::assign(_Ilist);
664  /*m_debug_size = size();*/
665  m_mmitset.reset();
666  }
mse::msevector::mm_iterator_set_type::reset
void reset()
Definition: msemsevector.h:1193

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ assign() [2/7]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign ( _It  _F,
_It  _L 
)
inline

Definition at line 335 of file msemsevector.h.

335  {
336  base_class::assign(_F, _L);
337  /*m_debug_size = size();*/
338  m_mmitset.reset();
339  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

Referenced by mse::msevector< _Ty, _A >::assign(), and mse::msevector< _Ty, _A >::msevector().

◆ assign() [3/7]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter >
void mse::msevector< _Ty, _A >::assign ( _Iter  _First,
_Iter  _Last 
)
inline

Definition at line 341 of file msemsevector.h.

341  { // assign [_First, _Last)
342  base_class::assign(_First, _Last);
343  /*m_debug_size = size();*/
344  m_mmitset.reset();
345  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ assign() [4/7]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign ( const cipointer &  start,
const cipointer &  end 
)
inline

Definition at line 1639 of file msemsevector.h.

1639  {
1640  assign(start.const_item_pointer(), end.const_item_pointer());
1641  }

References mse::msevector< _Ty, _A >::assign(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), and anonymous_namespace{stringutils.cpp}::start.

◆ assign() [5/7]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign ( const mm_const_iterator_type &  start,
const mm_const_iterator_type &  end 
)
inline

Definition at line 1627 of file msemsevector.h.

1627  {
1628  if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const mm_const_iterator_type &start, const mm_const_iterator_type &end) - msevector")); }
1629  if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const mm_const_iterator_type &start, const mm_const_iterator_type &end) - msevector")); }
1630  typename base_class::const_iterator _F = start;
1631  typename base_class::const_iterator _L = end;
1632  (*this).assign(_F, _L);
1633  }
MSE_THROW
#define MSE_THROW(x)
Definition: msemsevector.h:44

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, MSE_THROW, and anonymous_namespace{stringutils.cpp}::start.

◆ assign() [6/7]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign ( const ss_const_iterator_type &  start,
const ss_const_iterator_type &  end 
)
inline

Definition at line 2276 of file msemsevector.h.

2276  {
2277  if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
2278  if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
2279  typename base_class::const_iterator _F = start;
2280  typename base_class::const_iterator _L = end;
2281  (*this).assign(_F, _L);
2282  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, and anonymous_namespace{stringutils.cpp}::start.

◆ assign() [7/7]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign ( size_type  _N,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 346 of file msemsevector.h.

346  {
347  base_class::assign(msev_as_a_size_t(_N), _X);
348  /*m_debug_size = size();*/
349  m_mmitset.reset();
350  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ assign_inclusive() [1/3]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign_inclusive ( const cipointer &  first,
const cipointer &  last 
)
inline

Definition at line 1642 of file msemsevector.h.

1642  {
1643  assign_inclusive(first.const_item_pointer(), last.const_item_pointer());
1644  }
mse::msevector::assign_inclusive
void assign_inclusive(const mm_const_iterator_type &first, const mm_const_iterator_type &last)
Definition: msemsevector.h:1634

References mse::msevector< _Ty, _A >::assign_inclusive(), and mse::msevector< _Ty, _A >::cipointer::const_item_pointer().

◆ assign_inclusive() [2/3]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign_inclusive ( const mm_const_iterator_type &  first,
const mm_const_iterator_type &  last 
)
inline

Definition at line 1634 of file msemsevector.h.

1634  {
1635  auto end = last;
1636  end++; // this should include some checks
1637  (*this).assign(first, end);
1638  }

Referenced by mse::msevector< _Ty, _A >::assign_inclusive().

◆ assign_inclusive() [3/3]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::assign_inclusive ( const ss_const_iterator_type &  first,
const ss_const_iterator_type &  last 
)
inline

Definition at line 2283 of file msemsevector.h.

2283  {
2284  auto end = last;
2285  end++; // this should include some checks
2286  (*this).assign(first, end);
2287  }

◆ back() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::reference mse::msevector< _Ty, _A >::back ( )
inline

Definition at line 265 of file msemsevector.h.

265  { // return last element of mutable sequence
266  if (0 == (*this).size()) { MSE_THROW(msevector_range_error("back() on empty - typename base_class::reference back() - msevector")); }
267  return base_class::back();
268  }

References MSE_THROW.

◆ back() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::const_reference mse::msevector< _Ty, _A >::back ( ) const
inline

Definition at line 269 of file msemsevector.h.

269  { // return last element of nonmutable sequence
270  if (0 == (*this).size()) { MSE_THROW(msevector_range_error("back() on empty - typename base_class::const_reference back() - msevector")); }
271  return base_class::back();
272  }

References MSE_THROW.

◆ cibegin()

template<class _Ty , class _A = std::allocator<_Ty>>
cipointer mse::msevector< _Ty, _A >::cibegin ( ) const
inline

Definition at line 1611 of file msemsevector.h.

1611  { // return ipointer for beginning of nonmutable sequence
1612  cipointer retval(*this);
1613  retval.set_to_beginning();
1614  return retval;
1615  }

References mse::msevector< _Ty, _A >::cipointer::set_to_beginning().

◆ ciend()

template<class _Ty , class _A = std::allocator<_Ty>>
cipointer mse::msevector< _Ty, _A >::ciend ( ) const
inline

Definition at line 1616 of file msemsevector.h.

1616  { // return ipointer for end of nonmutable sequence
1617  cipointer retval(*this);
1618  retval.set_to_end_marker();
1619  return retval;
1620  }

References mse::msevector< _Ty, _A >::cipointer::set_to_end_marker().

◆ clear()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::clear ( )
inline

Definition at line 637 of file msemsevector.h.

637  {
638  base_class::clear();
639  /*m_debug_size = size();*/
640  m_mmitset.reset();
641  }
PlayerInfo::clear
void clear()
Definition: playerinfo.cpp:452

References PlayerInfo::clear(), mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ const_item_pointer()

template<class _Ty , class _A = std::allocator<_Ty>>
mm_const_iterator_type& mse::msevector< _Ty, _A >::const_item_pointer ( mm_const_iterator_handle_type  handle) const
inline

Definition at line 1430 of file msemsevector.h.

1430  {
1431  return m_mmitset.const_item_pointer(handle);
1432  }
mse::msevector::mm_iterator_set_type::const_item_pointer
mm_const_iterator_type & const_item_pointer(mm_const_iterator_handle_type handle) const
Definition: msemsevector.h:1377

References mse::msevector< _Ty, _A >::mm_iterator_set_type::const_item_pointer(), and mse::msevector< _Ty, _A >::m_mmitset.

Referenced by mse::msevector< _Ty, _A >::cipointer::const_item_pointer().

◆ emplace() [1/4]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class ... _Valty>
ipointer mse::msevector< _Ty, _A >::emplace ( const cipointer &  pos,
_Valty &&...  _Val 
)
inline

(defined(GPP4P8_COMPATIBLE))

Definition at line 1756 of file msemsevector.h.

1757  { // insert by moving _Val at pos
1758 #else
1759  ipointer emplace(const ipointer &pos, _Valty&& ..._Val)
1760  { // insert by moving _Val at pos
1761 #endif
1762  msev_size_t original_pos = pos.position();
1763  (*this).emplace(pos.const_item_pointer(), std::forward<_Valty>(_Val)...);
1764  ipointer retval(*this); retval.advance(msev_int(original_pos));
1765  return retval;
1766  }
mse::msevector::emplace
base_class::iterator emplace(typename base_class::const_iterator _Where, _Valty &&..._Val)
Definition: msemsevector.h:527
mse::msev_int
long int msev_int
Definition: msemsevector.h:62
mse::msev_size_t
size_t msev_size_t
Definition: msemsevector.h:61

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::emplace(), and mse::msevector< _Ty, _A >::cipointer::position().

◆ emplace() [2/4]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class ... _Valty>
void mse::msevector< _Ty, _A >::emplace ( const mm_const_iterator_type &  pos,
_Valty &&...  _Val 
)
inline

(defined(GPP4P8_COMPATIBLE))

Definition at line 1744 of file msemsevector.h.

1745  { // insert by moving _Val at pos
1746 #else
1747  void emplace(const mm_iterator_type &pos, _Valty&& ..._Val)
1748  { // insert by moving _Val at pos
1749 #endif
1750  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); }
1751  typename base_class::const_iterator _P = pos;
1752  auto retval = base_class::emplace(_P, std::forward<_Valty>(_Val)...);
1753  }

References mse::msevector< _Ty, _A >::emplace(), mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

◆ emplace() [3/4]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class ... _Valty>
ss_iterator_type mse::msevector< _Ty, _A >::emplace ( const ss_const_iterator_type &  pos,
_Valty &&...  _Val 
)
inline

(defined(GPP4P8_COMPATIBLE))

Definition at line 2373 of file msemsevector.h.

2374  { // insert by moving _Val at pos
2375  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); }
2376 #else
2377  ipointer emplace(const ipointer &pos, _Valty&& ..._Val)
2378  { // insert by moving _Val at pos
2379  if (pos.m_owner_ptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); }
2380 #endif
2381  pos.assert_valid_index();
2382  msev_size_t original_pos = pos.position();
2383  typename base_class::const_iterator _P = pos;
2384  (*this).emplace(_P, std::forward<_Valty>(_Val)...);
2385  ss_iterator_type retval = ss_begin();
2386  retval.advance(msev_int(original_pos));
2387  return retval;
2388  }
mse::msevector::ss_begin
ss_iterator_type ss_begin()
Definition: msemsevector.h:2199

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), mse::msevector< _Ty, _A >::emplace(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), and mse::msevector< _Ty, _A >::ss_begin().

◆ emplace() [4/4]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class ... _Valty>
base_class::iterator mse::msevector< _Ty, _A >::emplace ( typename base_class::const_iterator  _Where,
_Valty &&...  _Val 
)
inline

(defined(GPP4P8_COMPATIBLE))

(defined(GPP4P8_COMPATIBLE))

Definition at line 527 of file msemsevector.h.

528  { // insert by moving _Val at _Where
529 #else
530  typename base_class::iterator emplace(typename base_class::/*const_*/iterator _Where, _Valty&& ..._Val)
531  { // insert by moving _Val at _Where
532 #endif
534  if (m_mmitset.is_empty()) {
535  auto retval = base_class::emplace(_Where, std::forward<_Valty>(_Val)...);
536  /*m_debug_size = size();*/
537  return retval;
538  }
539  else {
540 
541 #if !(defined(GPP4P8_COMPATIBLE))
542  msev_int di = std::distance(base_class::cbegin(), _Where);
543 #else
544  msev_int di = std::distance(base_class::/*c*/begin(), _Where);
545 #endif
547  msev_size_t d = msev_size_t(di);
548  if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator emplace() - msevector")); }
549 
550  auto original_size = msev_size_t((*this).size());
551  auto original_capacity = msev_size_t((*this).capacity());
552 
553  auto retval = base_class::emplace(_Where, std::forward<_Valty>(_Val)...);
554  /*m_debug_size = size();*/
555 
556  assert((original_size + 1) == msev_size_t((*this).size()));
557  assert(di == std::distance(base_class::begin(), retval));
558  m_mmitset.shift_inclusive_range(d, original_size, 1);
559  auto new_capacity = msev_size_t((*this).capacity());
560  bool realloc_occured = (new_capacity != original_capacity);
561  if (realloc_occured) {
562  m_mmitset.sync_iterators_to_index();
563  }
564  return retval;
565  }
566  }
mse::msevector::mm_iterator_set_type::shift_inclusive_range
void shift_inclusive_range(msev_size_t start_index, msev_size_t end_index, msev_int shift)
Definition: msemsevector.h:1216
mse::msevector::mm_iterator_set_type::sync_iterators_to_index
void sync_iterators_to_index()
Definition: msemsevector.h:1200
mse::msevector::mm_iterator_set_type::is_empty
bool is_empty() const
Definition: msemsevector.h:1222

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

Referenced by mse::msevector< _Ty, _A >::emplace(), and mse::msevector< _Ty, _A >::insert().

◆ emplace_back()

template<class _Ty , class _A = std::allocator<_Ty>>
template<class ... _Valty>
void mse::msevector< _Ty, _A >::emplace_back ( _Valty &&...  _Val)
inline

(defined(GPP4P8_COMPATIBLE))

Definition at line 503 of file msemsevector.h.

504  { // insert by moving into element at end
505  if (m_mmitset.is_empty()) {
506  base_class::emplace_back(std::forward<_Valty>(_Val)...);
507  /*m_debug_size = size();*/
508  }
509  else {
510  auto original_size = msev_size_t((*this).size());
511  auto original_capacity = msev_size_t((*this).capacity());
512 
513  base_class::emplace_back(std::forward<_Valty>(_Val)...);
514  /*m_debug_size = size();*/
515 
516  assert((original_size + 1) == msev_size_t((*this).size()));
517  m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/
518  auto new_capacity = msev_size_t((*this).capacity());
519  bool realloc_occured = (new_capacity != original_capacity);
520  if (realloc_occured) {
521  m_mmitset.sync_iterators_to_index();
522  }
523  }
524  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ erase() [1/8]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::erase ( const cipointer &  pos)
inline

Definition at line 1788 of file msemsevector.h.

1788  {
1789  auto retval_pos = pos;
1790  retval_pos.set_to_next();
1791  erase(pos.const_item_pointer());
1792  ipointer retval = (*this).ibegin();
1793  retval.advance(msev_int(retval_pos.position()));
1794  return retval;
1795  }
mse::msevector::erase
base_class::iterator erase(typename base_class::const_iterator _P)
Definition: msemsevector.h:567

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::erase(), and mse::msevector< _Ty, _A >::cipointer::set_to_next().

◆ erase() [2/8]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::erase ( const cipointer &  start,
const cipointer &  end 
)
inline

Definition at line 1796 of file msemsevector.h.

1796  {
1797  auto retval_pos = end;
1798  retval_pos.set_to_next();
1799  erase(start.const_item_pointer(), end.const_item_pointer());
1800  ipointer retval = (*this).ibegin();
1801  retval.advance(msev_int(retval_pos.position()));
1802  return retval;
1803  }

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::erase(), mse::msevector< _Ty, _A >::cipointer::set_to_next(), and anonymous_namespace{stringutils.cpp}::start.

◆ erase() [3/8]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::erase ( const mm_const_iterator_type &  pos)
inline

Definition at line 1767 of file msemsevector.h.

1767  {
1768  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
1769  typename base_class::const_iterator _P = pos;
1770  (*this).erase(_P);
1771  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

◆ erase() [4/8]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::erase ( const mm_const_iterator_type &  start,
const mm_const_iterator_type &  end 
)
inline

Definition at line 1772 of file msemsevector.h.

1772  {
1773  if (start.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
1774  if (end.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
1775  typename base_class::const_iterator _F = start;
1776  typename base_class::const_iterator _L = end;
1777  (*this).erase(_F, _L);
1778  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, MSE_THROW, and anonymous_namespace{stringutils.cpp}::start.

◆ erase() [5/8]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::erase ( const ss_const_iterator_type &  pos)
inline

Definition at line 2389 of file msemsevector.h.

2389  {
2390  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
2391  if (!pos.points_to_an_item()) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
2392  auto pos_index = pos.position();
2393 
2394  typename base_class::const_iterator _P = pos;
2395  (*this).erase(_P);
2396 
2397  ss_iterator_type retval = (*this).ss_begin();
2398  retval.advance(typename ss_const_iterator_type::difference_type(pos_index));
2399  return retval;
2400  }
mse::msevector::ss_const_iterator_type::difference_type
_Myt::difference_type difference_type
Definition: msemsevector.h:1829

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::points_to_an_item(), and mse::msevector< _Ty, _A >::ss_const_iterator_type::position().

◆ erase() [6/8]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::erase ( const ss_const_iterator_type &  start,
const ss_const_iterator_type &  end 
)
inline

Definition at line 2401 of file msemsevector.h.

2401  {
2402  if (start.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
2403  if (end.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
2404  if (start.position() > end.position()) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
2405  auto pos_index = start.position();
2406 
2407  typename base_class::const_iterator _F = start;
2408  typename base_class::const_iterator _L = end;
2409  (*this).erase(_F, _L);
2410 
2411  ss_iterator_type retval = (*this).ss_begin();
2412  retval.advance(typename ss_const_iterator_type::difference_type(pos_index));
2413  return retval;
2414  }

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), and anonymous_namespace{stringutils.cpp}::start.

◆ erase() [7/8]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::iterator mse::msevector< _Ty, _A >::erase ( typename base_class::const_iterator  _F,
typename base_class::const_iterator  _L 
)
inline

Definition at line 599 of file msemsevector.h.

599  {
600  if (m_mmitset.is_empty()) {
601  typename base_class::iterator retval = base_class::erase(_F, _L);
602  /*m_debug_size = size();*/
603  return retval;
604  }
605  else {
606  msev_int di = std::distance(base_class::cbegin(), _F);
607  msev_size_t d = msev_size_t(di);
608  if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); }
609  msev_int di2 = std::distance(base_class::cbegin(), _L);
610  msev_size_t d2 = msev_size_t(di2);
611  if ((0 > di2) || ((*this).size() < msev_size_t(di2))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); }
612 
613  auto _M = msev_int(std::distance(_F, _L));
614  auto original_size = msev_size_t((*this).size());
615  auto original_capacity = msev_size_t((*this).capacity());
616 
617  if ((base_class::end() == _F)/* || (0 > _M)*/) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator erase(typename base_class::iterator _F, typename base_class::iterator _L) - msevector")); }
618  typename base_class::iterator retval = base_class::erase(_F, _L);
619  /*m_debug_size = size();*/
620 
621  assert((original_size - _M) == msev_size_t((*this).size()));
622  assert(di == std::distance(base_class::begin(), retval));
623  {
624  if (1 <= _M) {
625  m_mmitset.invalidate_inclusive_range(d, msev_size_t(d + _M - 1));
626  }
627  m_mmitset.shift_inclusive_range(msev_size_t(d + _M), original_size, -_M);
628  }
629  auto new_capacity = msev_size_t((*this).capacity());
630  bool realloc_occured = (new_capacity != original_capacity);
631  if (realloc_occured) {
632  m_mmitset.sync_iterators_to_index();
633  }
634  return retval;
635  }
636  }
mse::msevector::mm_iterator_set_type::invalidate_inclusive_range
void invalidate_inclusive_range(msev_size_t start_index, msev_size_t end_index)
Definition: msemsevector.h:1210

References mse::msevector< _Ty, _A >::mm_iterator_set_type::invalidate_inclusive_range(), mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ erase() [8/8]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::iterator mse::msevector< _Ty, _A >::erase ( typename base_class::const_iterator  _P)
inline

Definition at line 567 of file msemsevector.h.

567  {
568  if (m_mmitset.is_empty()) {
569  typename base_class::iterator retval = base_class::erase(_P);
570  /*m_debug_size = size();*/
571  return retval;
572  }
573  else {
574  msev_int di = std::distance(base_class::cbegin(), _P);
575  msev_size_t d = msev_size_t(di);
576  if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); }
577 
578  auto original_size = msev_size_t((*this).size());
579  auto original_capacity = msev_size_t((*this).capacity());
580 
581  if (base_class::end() == _P) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator erase(typename base_class::const_iterator _P) - msevector")); }
582  typename base_class::iterator retval = base_class::erase(_P);
583  /*m_debug_size = size();*/
584 
585  assert((original_size - 1) == msev_size_t((*this).size()));
586  assert(di == std::distance(base_class::begin(), retval));
587  {
588  m_mmitset.invalidate_inclusive_range(d, d);
589  m_mmitset.shift_inclusive_range(msev_size_t(d + 1), original_size, -1);
590  }
591  auto new_capacity = msev_size_t((*this).capacity());
592  bool realloc_occured = (new_capacity != original_capacity);
593  if (realloc_occured) {
594  m_mmitset.sync_iterators_to_index();
595  }
596  return retval;
597  }
598  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::invalidate_inclusive_range(), mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

Referenced by mse::msevector< _Ty, _A >::erase(), and mse::msevector< _Ty, _A >::erase_inclusive().

◆ erase_inclusive() [1/3]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::erase_inclusive ( const cipointer &  first,
const cipointer &  last 
)
inline

Definition at line 1804 of file msemsevector.h.

1804  {
1805  auto end = last; end.set_to_next();
1806  return erase(first, end);
1807  }

References mse::msevector< _Ty, _A >::erase(), and mse::msevector< _Ty, _A >::cipointer::set_to_next().

◆ erase_inclusive() [2/3]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::erase_inclusive ( const mm_const_iterator_type &  first,
const mm_const_iterator_type &  last 
)
inline

Definition at line 1779 of file msemsevector.h.

1779  {
1780  if (first.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_inclusive() - msevector")); }
1781  if (last.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_inclusive() - msevector")); }
1782  if (!(last.points_to_item())) { MSE_THROW(msevector_range_error("invalid argument - void erase_inclusive() - msevector")); }
1783  typename base_class::const_iterator _F = first;
1784  typename base_class::const_iterator _L = last;
1785  _L++;
1786  (*this).erase(_F, _L);
1787  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

◆ erase_inclusive() [3/3]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::erase_inclusive ( const ss_const_iterator_type &  first,
const ss_const_iterator_type &  last 
)
inline

Definition at line 2415 of file msemsevector.h.

2415  {
2416  auto end = last; end.set_to_next();
2417  return erase(first, end);
2418  }

References mse::msevector< _Ty, _A >::erase(), and mse::msevector< _Ty, _A >::ss_const_iterator_type::set_to_next().

◆ erase_previous_item() [1/3]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::erase_previous_item ( const cipointer &  pos)
inline

Definition at line 1815 of file msemsevector.h.

1815  {
1816  erase_previous_item(pos.const_item_pointer());
1817  ipointer retval = (*this).ibegin();
1818  retval.advance(pos.position());
1819  return retval;
1820  }
mse::msevector::erase_previous_item
void erase_previous_item(const mm_const_iterator_type &pos)
Definition: msemsevector.h:1808

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::erase_previous_item(), and mse::msevector< _Ty, _A >::cipointer::position().

◆ erase_previous_item() [2/3]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::erase_previous_item ( const mm_const_iterator_type &  pos)
inline

Definition at line 1808 of file msemsevector.h.

1808  {
1809  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
1810  if (!(pos.has_previous())) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
1811  typename base_class::const_iterator _P = pos;
1812  _P--;
1813  (*this).erase(_P);
1814  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::has_previous(), mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

Referenced by mse::msevector< _Ty, _A >::erase_previous_item().

◆ erase_previous_item() [3/3]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::erase_previous_item ( const ss_const_iterator_type &  pos)
inline

Definition at line 2419 of file msemsevector.h.

2419  {
2420  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
2421  if (!(pos.has_previous())) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
2422  typename base_class::const_iterator _P = pos;
2423  _P--;
2424  (*this).erase(_P);
2425  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::has_previous(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, and MSE_THROW.

◆ front() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::reference mse::msevector< _Ty, _A >::front ( )
inline

Definition at line 257 of file msemsevector.h.

257  { // return first element of mutable sequence
258  if (0 == (*this).size()) { MSE_THROW(msevector_range_error("front() on empty - typename base_class::reference front() - msevector")); }
259  return base_class::front();
260  }

References MSE_THROW.

◆ front() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::const_reference mse::msevector< _Ty, _A >::front ( ) const
inline

Definition at line 261 of file msemsevector.h.

261  { // return first element of nonmutable sequence
262  if (0 == (*this).size()) { MSE_THROW(msevector_range_error("front() on empty - typename base_class::const_reference front() - msevector")); }
263  return base_class::front();
264  }

References MSE_THROW.

◆ ibegin() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::ibegin ( )
inline

Definition at line 1591 of file msemsevector.h.

1591  { // return ipointer for beginning of mutable sequence
1592  ipointer retval(*this);
1593  retval.set_to_beginning();
1594  return retval;
1595  }

References mse::msevector< _Ty, _A >::ipointer::set_to_beginning().

◆ ibegin() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
cipointer mse::msevector< _Ty, _A >::ibegin ( ) const
inline

Definition at line 1596 of file msemsevector.h.

1596  { // return ipointer for beginning of nonmutable sequence
1597  cipointer retval(*this);
1598  retval.set_to_beginning();
1599  return retval;
1600  }

References mse::msevector< _Ty, _A >::cipointer::set_to_beginning().

◆ iend() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::iend ( )
inline

Definition at line 1601 of file msemsevector.h.

1601  { // return ipointer for end of mutable sequence
1602  ipointer retval(*this);
1603  retval.set_to_end_marker();
1604  return retval;
1605  }

References mse::msevector< _Ty, _A >::ipointer::set_to_end_marker().

◆ iend() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
cipointer mse::msevector< _Ty, _A >::iend ( ) const
inline

Definition at line 1606 of file msemsevector.h.

1606  { // return ipointer for end of nonmutable sequence
1607  cipointer retval(*this);
1608  retval.set_to_end_marker();
1609  return retval;
1610  }

References mse::msevector< _Ty, _A >::cipointer::set_to_end_marker().

◆ insert() [1/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert ( const cipointer &  pos,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 1741 of file msemsevector.h.

1741 { return insert_before(pos, _Ilist); }
mse::msevector::insert_before
void insert_before(const mm_const_iterator_type &pos, size_type _M, const _Ty &_X)
Definition: msemsevector.h:1645

References mse::msevector< _Ty, _A >::insert_before().

◆ insert() [2/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert ( const cipointer &  pos,
_Ty &&  _X 
)
inline

Definition at line 1735 of file msemsevector.h.

1735 { return insert_before(pos, std::move(_X)); }

References mse::msevector< _Ty, _A >::insert_before(), and Actions::move().

◆ insert() [3/16]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ipointer mse::msevector< _Ty, _A >::insert ( const cipointer &  pos,
const _Iter &  start,
const _Iter &  end 
)
inline

Definition at line 1740 of file msemsevector.h.

1740 { return insert_before(pos, start, end); }

References mse::msevector< _Ty, _A >::insert_before(), and anonymous_namespace{stringutils.cpp}::start.

◆ insert() [4/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert ( const cipointer &  pos,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 1736 of file msemsevector.h.

1736 { return insert_before(pos, _X); }

References mse::msevector< _Ty, _A >::insert_before().

◆ insert() [5/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert ( const cipointer &  pos,
size_type  _M,
const _Ty &  _X 
)
inline

Definition at line 1734 of file msemsevector.h.

1734 { return insert_before(pos, _M, _X); }

References mse::msevector< _Ty, _A >::insert_before().

◆ insert() [6/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert ( const ss_const_iterator_type &  pos,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 2370 of file msemsevector.h.

2370 { return insert_before(pos, _Ilist); }

References mse::msevector< _Ty, _A >::insert_before().

◆ insert() [7/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert ( const ss_const_iterator_type &  pos,
_Ty &&  _X 
)
inline

Definition at line 2363 of file msemsevector.h.

2363 { return insert_before(pos, std::move(_X)); }

References mse::msevector< _Ty, _A >::insert_before(), and Actions::move().

◆ insert() [8/16]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ss_iterator_type mse::msevector< _Ty, _A >::insert ( const ss_const_iterator_type &  pos,
const _Iter &  start,
const _Iter &  end 
)
inline

Definition at line 2368 of file msemsevector.h.

2368 { return insert_before(pos, start, end); }

References mse::msevector< _Ty, _A >::insert_before(), and anonymous_namespace{stringutils.cpp}::start.

◆ insert() [9/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert ( const ss_const_iterator_type &  pos,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 2364 of file msemsevector.h.

2364 { return insert_before(pos, _X); }

References mse::msevector< _Ty, _A >::insert_before().

◆ insert() [10/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert ( const ss_const_iterator_type &  pos,
const _Ty *  start,
const _Ty *&  end 
)
inline

Definition at line 2369 of file msemsevector.h.

2369 { return insert_before(pos, start, end); }

References mse::msevector< _Ty, _A >::insert_before(), and anonymous_namespace{stringutils.cpp}::start.

◆ insert() [11/16]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert ( const ss_const_iterator_type &  pos,
size_type  _M,
const _Ty &  _X 
)
inline

Definition at line 2362 of file msemsevector.h.

2362 { return insert_before(pos, _M, _X); }

References mse::msevector< _Ty, _A >::insert_before().

◆ insert() [12/16]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::iterator mse::msevector< _Ty, _A >::insert ( typename base_class::const_iterator  _P,
_Ty &&  _X 
)
inline

Definition at line 351 of file msemsevector.h.

351  {
352  return (emplace(_P, std::move(_X)));
353  }

References mse::msevector< _Ty, _A >::emplace(), and Actions::move().

◆ insert() [13/16]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::iterator mse::msevector< _Ty, _A >::insert ( typename base_class::const_iterator  _P,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 354 of file msemsevector.h.

354  {
355  if (m_mmitset.is_empty()) {
356  typename base_class::iterator retval = base_class::insert(_P, _X);
357  /*m_debug_size = size();*/
358  return retval;
359  }
360  else {
361  msev_int di = std::distance(base_class::cbegin(), _P);
362  msev_size_t d = msev_size_t(di);
363  if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
364 
365  auto original_size = msev_size_t((*this).size());
366  auto original_capacity = msev_size_t((*this).capacity());
367 
368  typename base_class::iterator retval = base_class::insert(_P, _X);
369  /*m_debug_size = size();*/
370 
371  assert((original_size + 1) == msev_size_t((*this).size()));
372  assert(di == std::distance(base_class::begin(), retval));
373  m_mmitset.shift_inclusive_range(d, original_size, 1);
374  auto new_capacity = msev_size_t((*this).capacity());
375  bool realloc_occured = (new_capacity != original_capacity);
376  if (realloc_occured) {
377  m_mmitset.sync_iterators_to_index();
378  }
379  return retval;
380  }
381  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ insert() [14/16]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::iterator mse::msevector< _Ty, _A >::insert ( typename base_class::const_iterator  _P,
size_type  _M,
const _Ty &  _X 
)
inline

Definition at line 384 of file msemsevector.h.

384  {
385  if (m_mmitset.is_empty()) {
386  typename base_class::iterator retval = base_class::insert(_P, msev_as_a_size_t(_M), _X);
387  /*m_debug_size = size();*/
388  return retval;
389  }
390  else {
391  msev_int di = std::distance(base_class::cbegin(), _P);
392  msev_size_t d = msev_size_t(di);
393  if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
394 
395  auto original_size = msev_size_t((*this).size());
396  auto original_capacity = msev_size_t((*this).capacity());
397 
398  typename base_class::iterator retval = base_class::insert(_P, msev_as_a_size_t(_M), _X);
399  /*m_debug_size = size();*/
400 
401  assert((original_size + _M) == msev_size_t((*this).size()));
402  assert(di == std::distance(base_class::begin(), retval));
403  m_mmitset.shift_inclusive_range(d, original_size, msev_int(_M));
404  auto new_capacity = msev_size_t((*this).capacity());
405  bool realloc_occured = (new_capacity != original_capacity);
406  if (realloc_occured) {
407  m_mmitset.sync_iterators_to_index();
408  }
409  return retval;
410  }
411  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ insert() [15/16]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::iterator mse::msevector< _Ty, _A >::insert ( typename base_class::const_iterator  _Where,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 692 of file msemsevector.h.

692  { // insert initializer_list
693  if (m_mmitset.is_empty()) {
694  auto retval = base_class::insert(_Where, _Ilist);
695  /*m_debug_size = size();*/
696  return retval;
697  }
698  else {
699  msev_int di = std::distance(base_class::cbegin(), _Where);
700  msev_size_t d = msev_size_t(di);
701  if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
702 
703  auto _M = _Ilist.size();
704  auto original_size = msev_size_t((*this).size());
705  auto original_capacity = msev_size_t((*this).capacity());
706 
707  auto retval = base_class::insert(_Where, _Ilist);
708  /*m_debug_size = size();*/
709 
710  assert((original_size + _M) == msev_size_t((*this).size()));
711  assert(di == std::distance(base_class::begin(), retval));
712  m_mmitset.shift_inclusive_range(d, original_size, msev_int(_M));
713  auto new_capacity = msev_size_t((*this).capacity());
714  bool realloc_occured = (new_capacity != original_capacity);
715  if (realloc_occured) {
716  m_mmitset.sync_iterators_to_index();
717  }
718  return retval;
719  }
720  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ insert() [16/16]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
base_class::iterator mse::msevector< _Ty, _A >::insert ( typename base_class::const_iterator  _Where,
_Iter  _First,
_Iter  _Last 
)
inline

Definition at line 415 of file msemsevector.h.

415  { // insert [_First, _Last) at _Where
416  if (m_mmitset.is_empty()) {
417  auto retval = base_class::insert(_Where, _First, _Last);
418  /*m_debug_size = size();*/
419  return retval;
420  }
421  else {
422  msev_int di = std::distance(base_class::cbegin(), _Where);
423  msev_size_t d = msev_size_t(di);
424  if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
425 
426  auto _M = msev_int(std::distance(_First, _Last));
427  auto original_size = msev_size_t((*this).size());
428  auto original_capacity = msev_size_t((*this).capacity());
429 
430  //if (0 > _M) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator insert() - msevector")); }
431  auto retval = base_class::insert(_Where, _First, _Last);
432  /*m_debug_size = size();*/
433 
434  assert((original_size + _M) == msev_size_t((*this).size()));
435  assert(di == std::distance(base_class::begin(), retval));
436  m_mmitset.shift_inclusive_range(d, original_size, _M);
437  auto new_capacity = msev_size_t((*this).capacity());
438  bool realloc_occured = (new_capacity != original_capacity);
439  if (realloc_occured) {
440  m_mmitset.sync_iterators_to_index();
441  }
442  return retval;
443  }
444  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ insert_before() [1/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert_before ( const cipointer &  pos,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 1711 of file msemsevector.h.

1711  { // insert initializer_list
1712  msev_size_t original_pos = pos.position();
1713  (*this).insert_before(pos.const_item_pointer(), _Ilist);
1714  ipointer retval(*this); retval.advance(msev_int(original_pos));
1715  return retval;
1716  }

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), and mse::msevector< _Ty, _A >::cipointer::position().

◆ insert_before() [2/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert_before ( const cipointer &  pos,
_Ty &&  _X 
)
inline

Definition at line 1688 of file msemsevector.h.

1688  {
1689  msev_size_t original_pos = pos.position();
1690  insert_before(pos.const_item_pointer(), std::move(_X));
1691  ipointer retval(*this); retval.advance(msev_int(original_pos));
1692  return retval;
1693  }

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::insert_before(), Actions::move(), and mse::msevector< _Ty, _A >::cipointer::position().

◆ insert_before() [3/21]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ipointer mse::msevector< _Ty, _A >::insert_before ( const cipointer &  pos,
const _Iter &  start,
const _Iter &  end 
)
inline

Definition at line 1698 of file msemsevector.h.

1698  {
1699  msev_size_t original_pos = pos.position();
1700  insert_before(pos.const_item_pointer(), start, end);
1701  ipointer retval(*this); retval.advance(msev_int(original_pos));
1702  return retval;
1703  }

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::insert_before(), mse::msevector< _Ty, _A >::cipointer::position(), and anonymous_namespace{stringutils.cpp}::start.

◆ insert_before() [4/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert_before ( const cipointer &  pos,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 1694 of file msemsevector.h.

1694 { return insert_before(pos, 1, _X); }

References mse::msevector< _Ty, _A >::insert_before().

Referenced by mse::msevector< _Ty, _A >::insert_before().

◆ insert_before() [5/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ipointer mse::msevector< _Ty, _A >::insert_before ( const cipointer &  pos,
size_type  _M,
const _Ty &  _X 
)
inline

Definition at line 1682 of file msemsevector.h.

1682  {
1683  msev_size_t original_pos = pos.position();
1684  insert_before(pos.const_item_pointer(), _M, _X);
1685  ipointer retval(*this); retval.advance(msev_int(original_pos));
1686  return retval;
1687  }

References mse::msevector< _Ty, _A >::ipointer::advance(), mse::msevector< _Ty, _A >::cipointer::const_item_pointer(), mse::msevector< _Ty, _A >::insert_before(), and mse::msevector< _Ty, _A >::cipointer::position().

◆ insert_before() [6/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( const mm_const_iterator_type &  pos,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 1677 of file msemsevector.h.

1677  { // insert initializer_list
1678  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
1679  typename base_class::const_iterator _P = pos;
1680  (*this).insert(_P, _Ilist);
1681  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

◆ insert_before() [7/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( const mm_const_iterator_type &  pos,
_Ty &&  _X 
)
inline

Definition at line 1650 of file msemsevector.h.

1650  {
1651  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
1652  typename base_class::const_iterator _P = pos;
1653  (*this).insert(_P, 1, std::move(_X));
1654  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, Actions::move(), and MSE_THROW.

◆ insert_before() [8/21]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
void mse::msevector< _Ty, _A >::insert_before ( const mm_const_iterator_type &  pos,
const _Iter &  start,
const _Iter &  end 
)
inline

Definition at line 1659 of file msemsevector.h.

1659  {
1660  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
1661  //if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const mm_const_iterator_type &pos, const mm_const_iterator_type &start, const mm_const_iterator_type &end) - msevector")); }
1662  typename base_class::const_iterator _P = pos;
1663  (*this).insert(_P, start, end);
1664  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, MSE_THROW, and anonymous_namespace{stringutils.cpp}::start.

◆ insert_before() [9/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( const mm_const_iterator_type &  pos,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 1655 of file msemsevector.h.

1655 { (*this).insert(pos, 1, _X); }

◆ insert_before() [10/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( const mm_const_iterator_type &  pos,
size_type  _M,
const _Ty &  _X 
)
inline

Definition at line 1645 of file msemsevector.h.

1645  {
1646  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
1647  typename base_class::const_iterator _P = pos;
1648  (*this).insert(_P, _M, _X);
1649  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

Referenced by mse::msevector< _Ty, _A >::insert(), mse::msevector< _Ty, _A >::insert_before(), and mse::msevector< _Ty, _A >::insert_before_inclusive().

◆ insert_before() [11/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 2351 of file msemsevector.h.

2351  { // insert initializer_list
2352  if (pos.m_owner_ptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
2353  pos.assert_valid_index();
2354  msev_size_t original_pos = pos.position();
2355  typename base_class::const_iterator _P = pos;
2356  (*this).insert(_P, _Ilist);
2357  ss_iterator_type retval = ss_begin();
2358  retval.advance(msev_int(original_pos));
2359  return retval;
2360  }

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), and mse::msevector< _Ty, _A >::ss_begin().

◆ insert_before() [12/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
_Ty &&  _X 
)
inline

Definition at line 2298 of file msemsevector.h.

2298  {
2299  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - void insert_before() - msevector")); }
2300  pos.assert_valid_index();
2301  msev_size_t original_pos = pos.position();
2302  typename base_class::const_iterator _P = pos;
2303  (*this).insert(_P, std::move(_X));
2304  ss_iterator_type retval = ss_begin();
2305  retval.advance(msev_int(original_pos));
2306  return retval;
2307  }

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, Actions::move(), MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), and mse::msevector< _Ty, _A >::ss_begin().

◆ insert_before() [13/21]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
const _Iter &  start,
const _Iter &  end 
)
inline

Definition at line 2312 of file msemsevector.h.

2312  {
2313  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type insert_before() - msevector")); }
2314  //if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
2315  pos.assert_valid_index();
2316  msev_size_t original_pos = pos.position();
2317  typename base_class::const_iterator _P = pos;
2318  (*this).insert(_P, start, end);
2319  ss_iterator_type retval = ss_begin();
2320  retval.advance(msev_int(original_pos));
2321  return retval;
2322  }

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), mse::msevector< _Ty, _A >::ss_begin(), and anonymous_namespace{stringutils.cpp}::start.

◆ insert_before() [14/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 2308 of file msemsevector.h.

2308 { return (*this).insert(pos, 1, _X); }

◆ insert_before() [15/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
const _Ty *  start,
const _Ty *  end 
)
inline

Definition at line 2331 of file msemsevector.h.

2331  {
2332  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - ss_iterator_type insert_before() - msevector")); }
2333  //if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
2334  if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - ss_iterator_type insert_before() - msevector")); }
2335  pos.assert_valid_index();
2336  msev_size_t original_pos = pos.position();
2337  typename base_class::const_iterator _P = pos;
2338  (*this).insert(_P, start, end);
2339  ss_iterator_type retval = ss_begin();
2340  retval.advance(msev_int(original_pos));
2341  return retval;
2342  }

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), mse::msevector< _Ty, _A >::ss_begin(), and anonymous_namespace{stringutils.cpp}::start.

◆ insert_before() [16/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
const ss_const_iterator_type &  start,
const ss_const_iterator_type &  end 
)
inline

Definition at line 2323 of file msemsevector.h.

2323  {
2324  if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
2325  end.assert_valid_index();
2326  if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
2327  typename base_class::const_iterator _S = start;
2328  typename base_class::const_iterator _E = end;
2329  return (*this).insert_before(pos, _S, _E);
2330  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, and anonymous_namespace{stringutils.cpp}::start.

◆ insert_before() [17/21]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before ( const ss_const_iterator_type &  pos,
size_type  _M,
const _Ty &  _X 
)
inline

Definition at line 2288 of file msemsevector.h.

2288  {
2289  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - void insert_before() - msevector")); }
2290  pos.assert_valid_index();
2291  msev_size_t original_pos = pos.position();
2292  typename base_class::const_iterator _P = pos;
2293  (*this).insert(_P, _M, _X);
2294  ss_iterator_type retval = ss_begin();
2295  retval.advance(msev_int(original_pos));
2296  return retval;
2297  }

References mse::msevector< _Ty, _A >::ss_iterator_type::advance(), mse::msevector< _Ty, _A >::ss_const_iterator_type::assert_valid_index(), mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, MSE_THROW, mse::msevector< _Ty, _A >::ss_const_iterator_type::position(), and mse::msevector< _Ty, _A >::ss_begin().

◆ insert_before() [18/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( msev_size_t  pos,
::std::initializer_list< typename base_class::value_type >  _Ilist 
)
inline

Definition at line 1729 of file msemsevector.h.

1729  { // insert initializer_list
1730  typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
1731  (*this).insert(_P, _Ilist);
1732  }

◆ insert_before() [19/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( msev_size_t  pos,
_Ty &&  _X 
)
inline

Definition at line 1717 of file msemsevector.h.

1717  {
1718  typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
1719  (*this).insert(_P, std::move(_X));
1720  }

References Actions::move().

◆ insert_before() [20/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( msev_size_t  pos,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 1721 of file msemsevector.h.

1721  {
1722  typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
1723  (*this).insert(_P, _X);
1724  }

◆ insert_before() [21/21]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::insert_before ( msev_size_t  pos,
size_t  _M,
const _Ty &  _X 
)
inline

Definition at line 1725 of file msemsevector.h.

1725  {
1726  typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
1727  (*this).insert(_P, _M, _X);
1728  }

◆ insert_before_inclusive() [1/3]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ipointer mse::msevector< _Ty, _A >::insert_before_inclusive ( const cipointer &  pos,
const _Iter &  first,
const _Iter &  last 
)
inline

Definition at line 1707 of file msemsevector.h.

1707  {
1708  auto end = last; end++;
1709  return insert_before(pos, first, end);
1710  }

References mse::msevector< _Ty, _A >::insert_before().

◆ insert_before_inclusive() [2/3]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
void mse::msevector< _Ty, _A >::insert_before_inclusive ( const mm_const_iterator_type &  pos,
const _Iter &  first,
const _Iter &  last 
)
inline

Definition at line 1668 of file msemsevector.h.

1668  {
1669  if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
1670  if (first.m_owner_cptr != last.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before_inclusive(const mm_const_iterator_type &pos, const mm_const_iterator_type &first, const mm_const_iterator_type &last) - msevector")); }
1671  if (!(last.points_to_item())) { MSE_THROW(msevector_range_error("invalid argument - void insert_before_inclusive(const mm_const_iterator_type &pos, const mm_const_iterator_type &first, const mm_const_iterator_type &last) - msevector")); }
1672  typename base_class::const_iterator _P = pos;
1673  auto _L = last;
1674  _L++;
1675  (*this).insert(_P, first, _L);
1676  }

References mse::msevector< _Ty, _A >::mm_const_iterator_type::m_owner_cptr, and MSE_THROW.

◆ insert_before_inclusive() [3/3]

template<class _Ty , class _A = std::allocator<_Ty>>
template<class _Iter , class = _mse_RequireInputIter<_Iter>>
ss_iterator_type mse::msevector< _Ty, _A >::insert_before_inclusive ( const ss_iterator_type &  pos,
const _Iter &  first,
const _Iter &  last 
)
inline

Definition at line 2346 of file msemsevector.h.

2346  {
2347  auto end = last;
2348  end++; // this may include some checks
2349  return (*this).insert_before(pos, first, end);
2350  }

◆ item_pointer()

template<class _Ty , class _A = std::allocator<_Ty>>
mm_iterator_type& mse::msevector< _Ty, _A >::item_pointer ( mm_iterator_handle_type  handle)
inline

Definition at line 1433 of file msemsevector.h.

1433  {
1434  return m_mmitset.item_pointer(handle);
1435  }
mse::msevector::mm_iterator_set_type::item_pointer
mm_iterator_type & item_pointer(mm_iterator_handle_type handle)
Definition: msemsevector.h:1380

References mse::msevector< _Ty, _A >::mm_iterator_set_type::item_pointer(), and mse::msevector< _Ty, _A >::m_mmitset.

Referenced by mse::msevector< _Ty, _A >::ipointer::item_pointer().

◆ operator=() [1/4]

template<class _Ty , class _A = std::allocator<_Ty>>
_Myt& mse::msevector< _Ty, _A >::operator= ( ::std::initializer_list< typename base_class::value_type >  _Ilist)
inline

Definition at line 657 of file msemsevector.h.

657  { // assign initializer_list
658  operator=(static_cast<base_class>(_Ilist));
659  m_mmitset.reset();
660  return (*this);
661  }
mse::msevector::operator=
_Myt & operator=(const base_class &_X)
Definition: msemsevector.h:194

References mse::msevector< _Ty, _A >::m_mmitset, mse::msevector< _Ty, _A >::operator=(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ operator=() [2/4]

template<class _Ty , class _A = std::allocator<_Ty>>
_Myt& mse::msevector< _Ty, _A >::operator= ( _Myt &&  _X)
inline

Definition at line 200 of file msemsevector.h.

200  {
201  operator=(std::move(static_cast<base_class&>(_X)));
202  m_mmitset.reset();
203  return (*this);
204  }

References mse::msevector< _Ty, _A >::m_mmitset, Actions::move(), mse::msevector< _Ty, _A >::operator=(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ operator=() [3/4]

template<class _Ty , class _A = std::allocator<_Ty>>
_Myt& mse::msevector< _Ty, _A >::operator= ( const _Myt &  _X)
inline

Definition at line 205 of file msemsevector.h.

205  {
206  operator=(static_cast<const base_class&>(_X));
207  m_mmitset.reset();
208  return (*this);
209  }

References mse::msevector< _Ty, _A >::m_mmitset, mse::msevector< _Ty, _A >::operator=(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

◆ operator=() [4/4]

template<class _Ty , class _A = std::allocator<_Ty>>
_Myt& mse::msevector< _Ty, _A >::operator= ( const base_class &  _X)
inline

Definition at line 194 of file msemsevector.h.

194  {
195  base_class::operator =(_X);
196  /*m_debug_size = size();*/
197  m_mmitset.reset();
198  return (*this);
199  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

Referenced by mse::msevector< _Ty, _A >::operator=().

◆ operator[]() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::reference mse::msevector< _Ty, _A >::operator[] ( size_type  _P)
inline

Definition at line 254 of file msemsevector.h.

254  {
255  return (*this).at(msev_as_a_size_t(_P));
256  }

◆ operator[]() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
base_class::const_reference mse::msevector< _Ty, _A >::operator[] ( size_type  _P) const
inline

Definition at line 251 of file msemsevector.h.

251  {
252  return (*this).at(msev_as_a_size_t(_P));
253  }

◆ pop_back()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::pop_back ( )
inline

Definition at line 313 of file msemsevector.h.

313  {
314  if (m_mmitset.is_empty()) {
315  base_class::pop_back();
316  }
317  else {
318  auto original_size = msev_size_t((*this).size());
319  auto original_capacity = msev_size_t((*this).capacity());
320 
321  if (0 == original_size) { MSE_THROW(msevector_range_error("pop_back() on empty - void pop_back() - msevector")); }
322  base_class::pop_back();
323  /*m_debug_size = size();*/
324 
325  assert((original_size - 1) == msev_size_t((*this).size()));
326  m_mmitset.invalidate_inclusive_range(msev_size_t(original_size - 1), msev_size_t(original_size - 1));
327  m_mmitset.shift_inclusive_range(original_size, original_size, -1); /*shift the end markers*/
328  auto new_capacity = msev_size_t((*this).capacity());
329  bool realloc_occured = (new_capacity != original_capacity);
330  if (realloc_occured) {
331  m_mmitset.sync_iterators_to_index();
332  }
333  }
334  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::invalidate_inclusive_range(), mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, MSE_THROW, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ push_back() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::push_back ( _Ty &&  _X)
inline

Definition at line 273 of file msemsevector.h.

273  {
274  if (m_mmitset.is_empty()) {
275  base_class::push_back(std::move(_X));
276  }
277  else {
278  auto original_size = msev_size_t((*this).size());
279  auto original_capacity = msev_size_t((*this).capacity());
280 
281  base_class::push_back(std::move(_X));
282  /*m_debug_size = size();*/
283 
284  assert((original_size + 1) == msev_size_t((*this).size()));
285  m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/
286  auto new_capacity = msev_size_t((*this).capacity());
287  bool realloc_occured = (new_capacity != original_capacity);
288  if (realloc_occured) {
289  m_mmitset.sync_iterators_to_index();
290  }
291  }
292  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, Actions::move(), mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ push_back() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::push_back ( const _Ty &  _X)
inline

Definition at line 293 of file msemsevector.h.

293  {
294  if (m_mmitset.is_empty()) {
295  base_class::push_back(_X);
296  }
297  else {
298  auto original_size = msev_size_t((*this).size());
299  auto original_capacity = msev_size_t((*this).capacity());
300 
301  base_class::push_back(_X);
302  /*m_debug_size = size();*/
303 
304  assert((original_size + 1) == msev_size_t((*this).size()));
305  m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/
306  auto new_capacity = msev_size_t((*this).capacity());
307  bool realloc_occured = (new_capacity != original_capacity);
308  if (realloc_occured) {
309  m_mmitset.sync_iterators_to_index();
310  }
311  }
312  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::is_empty(), mse::msevector< _Ty, _A >::m_mmitset, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ release_all_const_item_pointers()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::release_all_const_item_pointers ( ) const
inlineprivate

Definition at line 1440 of file msemsevector.h.

1440 { m_mmitset.release_all_const_item_pointers(); }
mse::msevector::mm_iterator_set_type::release_all_const_item_pointers
void release_all_const_item_pointers()
Definition: msemsevector.h:1385

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::release_all_const_item_pointers().

◆ release_all_item_pointers()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::release_all_item_pointers ( ) const
inlineprivate

Definition at line 1443 of file msemsevector.h.

1443 { m_mmitset.release_all_item_pointers(); }
mse::msevector::mm_iterator_set_type::release_all_item_pointers
void release_all_item_pointers()
Definition: msemsevector.h:1366

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::release_all_item_pointers().

◆ release_const_item_pointer()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::release_const_item_pointer ( mm_const_iterator_handle_type  handle) const
inlineprivate

Definition at line 1439 of file msemsevector.h.

1439 { m_mmitset.release_const_item_pointer(handle); }
mse::msevector::mm_iterator_set_type::release_const_item_pointer
void release_const_item_pointer(mm_const_iterator_handle_type handle)
Definition: msemsevector.h:1273

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::release_const_item_pointer().

Referenced by mse::msevector< _Ty, _A >::cipointer::~cipointer().

◆ release_item_pointer()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::release_item_pointer ( mm_iterator_handle_type  handle) const
inlineprivate

Definition at line 1442 of file msemsevector.h.

1442 { m_mmitset.release_item_pointer(handle); }
mse::msevector::mm_iterator_set_type::release_item_pointer
void release_item_pointer(mm_iterator_handle_type handle)
Definition: msemsevector.h:1334

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::release_item_pointer().

Referenced by mse::msevector< _Ty, _A >::ipointer::~ipointer().

◆ reserve()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::reserve ( size_type  _Count)
inline

Definition at line 210 of file msemsevector.h.

211  { // determine new minimum length of allocated storage
212  auto original_capacity = msev_size_t((*this).capacity());
213 
214  base_class::reserve(msev_as_a_size_t(_Count));
215 
216  auto new_capacity = msev_size_t((*this).capacity());
217  bool realloc_occured = (new_capacity != original_capacity);
218  if (realloc_occured) {
219  m_mmitset.sync_iterators_to_index();
220  }
221  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ resize()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::resize ( size_type  _N,
const _Ty &  _X = _Ty() 
)
inline

Definition at line 233 of file msemsevector.h.

233  {
234  auto original_size = msev_size_t((*this).size());
235  auto original_capacity = msev_size_t((*this).capacity());
236  bool shrinking = (_N < original_size);
237 
238  base_class::resize(msev_as_a_size_t(_N), _X);
239  /*m_debug_size = size();*/
240 
241  if (shrinking) {
242  m_mmitset.invalidate_inclusive_range(_N, msev_size_t(original_size - 1));
243  }
244  m_mmitset.shift_inclusive_range(original_size, original_size, msev_size_t(_N) - original_size); /*shift the end markers*/
245  auto new_capacity = msev_size_t((*this).capacity());
246  bool realloc_occured = (new_capacity != original_capacity);
247  if (realloc_occured) {
248  m_mmitset.sync_iterators_to_index();
249  }
250  }

References mse::msevector< _Ty, _A >::mm_iterator_set_type::invalidate_inclusive_range(), mse::msevector< _Ty, _A >::m_mmitset, mse::msevector< _Ty, _A >::mm_iterator_set_type::shift_inclusive_range(), and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ shrink_to_fit()

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::shrink_to_fit ( )
inline

Definition at line 222 of file msemsevector.h.

222  { // reduce capacity
223  auto original_capacity = msev_size_t((*this).capacity());
224 
225  base_class::shrink_to_fit();
226 
227  auto new_capacity = msev_size_t((*this).capacity());
228  bool realloc_occured = (new_capacity != original_capacity);
229  if (realloc_occured) {
230  m_mmitset.sync_iterators_to_index();
231  }
232  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::sync_iterators_to_index().

◆ ss_begin() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::ss_begin ( )
inline

Definition at line 2199 of file msemsevector.h.

2200  { // return base_class::iterator for beginning of mutable sequence
2201  ss_iterator_type retval; retval.m_owner_ptr = this;
2202  retval.set_to_beginning();
2203  return retval;
2204  }

References mse::msevector< _Ty, _A >::ss_iterator_type::m_owner_ptr, and mse::msevector< _Ty, _A >::ss_iterator_type::set_to_beginning().

Referenced by mse::msevector< _Ty, _A >::emplace(), mse::msevector< _Ty, _A >::insert_before(), and mse::msevector< _Ty, _A >::ss_rend().

◆ ss_begin() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_iterator_type mse::msevector< _Ty, _A >::ss_begin ( ) const
inline

Definition at line 2206 of file msemsevector.h.

2207  { // return base_class::iterator for beginning of nonmutable sequence
2208  ss_const_iterator_type retval; retval.m_owner_cptr = this;
2209  retval.set_to_beginning();
2210  return retval;
2211  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, and mse::msevector< _Ty, _A >::ss_const_iterator_type::set_to_beginning().

◆ ss_cbegin()

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_iterator_type mse::msevector< _Ty, _A >::ss_cbegin ( ) const
inline

Definition at line 2227 of file msemsevector.h.

2228  { // return base_class::iterator for beginning of nonmutable sequence
2229  ss_const_iterator_type retval; retval.m_owner_cptr = this;
2230  retval.set_to_beginning();
2231  return retval;
2232  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, and mse::msevector< _Ty, _A >::ss_const_iterator_type::set_to_beginning().

◆ ss_cend()

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_iterator_type mse::msevector< _Ty, _A >::ss_cend ( ) const
inline

Definition at line 2234 of file msemsevector.h.

2235  { // return base_class::iterator for end of nonmutable sequence
2236  ss_const_iterator_type retval; retval.m_owner_cptr = this;
2237  retval.set_to_end_marker();
2238  return retval;
2239  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, and mse::msevector< _Ty, _A >::ss_const_iterator_type::set_to_end_marker().

◆ ss_crbegin()

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_reverse_iterator_type mse::msevector< _Ty, _A >::ss_crbegin ( ) const
inline

Definition at line 2241 of file msemsevector.h.

2242  { // return base_class::iterator for beginning of reversed nonmutable sequence
2243  return (ss_rbegin());
2244  }
mse::msevector::ss_rbegin
ss_reverse_iterator_type ss_rbegin()
Definition: msemsevector.h:2251

References mse::msevector< _Ty, _A >::ss_rbegin().

◆ ss_crend()

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_reverse_iterator_type mse::msevector< _Ty, _A >::ss_crend ( ) const
inline

Definition at line 2246 of file msemsevector.h.

2247  { // return base_class::iterator for end of reversed nonmutable sequence
2248  return (ss_rend());
2249  }
mse::msevector::ss_rend
ss_reverse_iterator_type ss_rend()
Definition: msemsevector.h:2261

References mse::msevector< _Ty, _A >::ss_rend().

◆ ss_end() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_iterator_type mse::msevector< _Ty, _A >::ss_end ( )
inline

Definition at line 2213 of file msemsevector.h.

2214  { // return base_class::iterator for end of mutable sequence
2215  ss_iterator_type retval; retval.m_owner_ptr = this;
2216  retval.set_to_end_marker();
2217  return retval;
2218  }

References mse::msevector< _Ty, _A >::ss_iterator_type::m_owner_ptr, and mse::msevector< _Ty, _A >::ss_iterator_type::set_to_end_marker().

Referenced by mse::msevector< _Ty, _A >::ss_rbegin().

◆ ss_end() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_iterator_type mse::msevector< _Ty, _A >::ss_end ( ) const
inline

Definition at line 2220 of file msemsevector.h.

2221  { // return base_class::iterator for end of nonmutable sequence
2222  ss_const_iterator_type retval; retval.m_owner_cptr = this;
2223  retval.set_to_end_marker();
2224  return retval;
2225  }

References mse::msevector< _Ty, _A >::ss_const_iterator_type::m_owner_cptr, and mse::msevector< _Ty, _A >::ss_const_iterator_type::set_to_end_marker().

◆ ss_rbegin() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_reverse_iterator_type mse::msevector< _Ty, _A >::ss_rbegin ( )
inline

Definition at line 2251 of file msemsevector.h.

2252  { // return base_class::iterator for beginning of reversed mutable sequence
2253  return (reverse_iterator(ss_end()));
2254  }
mse::msevector::ss_end
ss_iterator_type ss_end()
Definition: msemsevector.h:2213

References mse::msevector< _Ty, _A >::ss_end().

Referenced by mse::msevector< _Ty, _A >::ss_crbegin().

◆ ss_rbegin() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_reverse_iterator_type mse::msevector< _Ty, _A >::ss_rbegin ( ) const
inline

Definition at line 2256 of file msemsevector.h.

2257  { // return base_class::iterator for beginning of reversed nonmutable sequence
2258  return (const_reverse_iterator(ss_end()));
2259  }

References mse::msevector< _Ty, _A >::ss_end().

◆ ss_rend() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_reverse_iterator_type mse::msevector< _Ty, _A >::ss_rend ( )
inline

Definition at line 2261 of file msemsevector.h.

2262  { // return base_class::iterator for end of reversed mutable sequence
2263  return (reverse_iterator(ss_begin()));
2264  }

References mse::msevector< _Ty, _A >::ss_begin().

Referenced by mse::msevector< _Ty, _A >::ss_crend().

◆ ss_rend() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
ss_const_reverse_iterator_type mse::msevector< _Ty, _A >::ss_rend ( ) const
inline

Definition at line 2266 of file msemsevector.h.

2267  { // return base_class::iterator for end of reversed nonmutable sequence
2268  return (const_reverse_iterator(ss_begin()));
2269  }

References mse::msevector< _Ty, _A >::ss_begin().

◆ swap() [1/2]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::swap ( _Myt &  _X)
inline

Definition at line 647 of file msemsevector.h.

647  {
648  swap(static_cast<base_class&>(_X));
649  m_mmitset.reset();
650  }
mse::msevector::swap
void swap(base_class &_X)
Definition: msemsevector.h:642

References mse::msevector< _Ty, _A >::m_mmitset, mse::msevector< _Ty, _A >::mm_iterator_set_type::reset(), and mse::msevector< _Ty, _A >::swap().

◆ swap() [2/2]

template<class _Ty , class _A = std::allocator<_Ty>>
void mse::msevector< _Ty, _A >::swap ( base_class &  _X)
inline

Definition at line 642 of file msemsevector.h.

642  {
643  base_class::swap(_X);
644  /*m_debug_size = size();*/
645  m_mmitset.reset();
646  }

References mse::msevector< _Ty, _A >::m_mmitset, and mse::msevector< _Ty, _A >::mm_iterator_set_type::reset().

Referenced by mse::msevector< _Ty, _A >::swap().

Field Documentation

◆ m_mmitset

template<class _Ty , class _A = std::allocator<_Ty>>
mm_iterator_set_type mse::msevector< _Ty, _A >::m_mmitset
mutableprivate

Definition at line 1427 of file msemsevector.h.

Referenced by mse::msevector< _Ty, _A >::allocate_new_const_item_pointer(), mse::msevector< _Ty, _A >::allocate_new_item_pointer(), mse::msevector< _Ty, _A >::assign(), mse::msevector< _Ty, _A >::clear(), mse::msevector< _Ty, _A >::const_item_pointer(), mse::msevector< _Ty, _A >::emplace(), mse::msevector< _Ty, _A >::emplace_back(), mse::msevector< _Ty, _A >::erase(), mse::msevector< _Ty, _A >::insert(), mse::msevector< _Ty, _A >::item_pointer(), mse::msevector< _Ty, _A >::operator=(), mse::msevector< _Ty, _A >::pop_back(), mse::msevector< _Ty, _A >::push_back(), mse::msevector< _Ty, _A >::release_all_const_item_pointers(), mse::msevector< _Ty, _A >::release_all_item_pointers(), mse::msevector< _Ty, _A >::release_const_item_pointer(), mse::msevector< _Ty, _A >::release_item_pointer(), mse::msevector< _Ty, _A >::reserve(), mse::msevector< _Ty, _A >::resize(), mse::msevector< _Ty, _A >::shrink_to_fit(), and mse::msevector< _Ty, _A >::swap().

The documentation for this class was generated from the following file:
Generated on Wed Mar 17 2021 19:19:19 for ManaPlus by doxygen 1.9.1