diff options
Diffstat (limited to 'src/debug/mse/msemsevector.h')
| -rw-r--r-- | src/debug/mse/msemsevector.h | 2433 |
1 files changed, 2433 insertions, 0 deletions
diff --git a/src/debug/mse/msemsevector.h b/src/debug/mse/msemsevector.h new file mode 100644 index 000000000..5ac2c4536 --- /dev/null +++ b/src/debug/mse/msemsevector.h @@ -0,0 +1,2433 @@ + +// Copyright (c) 2015 Noah Lopez +// Use, modification, and distribution is subject to the Boost Software +// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#pragma once +#ifndef MSEMSEVECTOR_H +#define MSEMSEVECTOR_H + +/*compiler specific defines*/ +#ifdef _MSC_VER +#if (1700 > _MSC_VER) +#define MSVC2010_COMPATIBLE 1 +#endif /*(1700 > _MSC_VER)*/ +#if (1900 > _MSC_VER) +#define MSVC2013_COMPATIBLE 1 +#endif /*(1900 > _MSC_VER)*/ +#else /*_MSC_VER*/ +#if (defined(__GNUC__) || defined(__GNUG__)) +#define GPP_COMPATIBLE 1 +#if ((5 > __GNUC__) && (!defined(__clang__))) +#define GPP4P8_COMPATIBLE 1 +#endif /*((5 > __GNUC__) && (!defined(__clang__)))*/ +#endif +#endif /*_MSC_VER*/ + +//define MSE_MSEVECTOR_USE_MSE_PRIMITIVES 1 +#ifdef MSE_MSEVECTOR_USE_MSE_PRIMITIVES +#include "debug/mse/mseprimitives.h" +#endif // MSE_MSEVECTOR_USE_MSE_PRIMITIVES + +#include <vector> +#include <assert.h> +#include <memory> +#include <unordered_map> +#include <functional> +#include <climits> // ULONG_MAX +#include <stdexcept> + +#ifdef MSE_CUSTOM_THROW_DEFINITION +#include <iostream> +#define MSE_THROW(x) MSE_CUSTOM_THROW_DEFINITION(x) +#else // MSE_CUSTOM_THROW_DEFINITION +#define MSE_THROW(x) throw(x) +#endif // MSE_CUSTOM_THROW_DEFINITION + +namespace mse { + +#ifdef MSE_MSEVECTOR_USE_MSE_PRIMITIVES + typedef mse::CSize_t msev_size_t; + typedef mse::CInt msev_int; + typedef bool msev_bool; // no added safety benefit to using mse::CBool in this case + #define msev_as_a_size_t as_a_size_t +#else // MSE_MSEVECTOR_USE_MSE_PRIMITIVES +#if SIZE_MAX <= ULONG_MAX +#define MSE_MSEVECTOR_BASE_INTEGER_TYPE long int +#else // SIZE_MAX <= ULONG_MAX +#define MSE_MSEVECTOR_BASE_INTEGER_TYPE long long int +#endif // SIZE_MAX <= ULONG_MAX + + typedef size_t msev_size_t; + typedef MSE_MSEVECTOR_BASE_INTEGER_TYPE msev_int; + typedef bool msev_bool; + typedef size_t msev_as_a_size_t; +#endif // MSE_MSEVECTOR_USE_MSE_PRIMITIVES + + + class msevector_range_error : public std::range_error { public: + using std::range_error::range_error; + }; + class msevector_null_dereference_error : public std::logic_error { public: + using std::logic_error::logic_error; + }; + + /* msev_pointer behaves similar to native pointers. It's a bit safer in that it initializes to + nullptr by default and checks for attempted dereference of null pointers. */ + template<typename _Ty> + class msev_pointer { + public: + msev_pointer() : m_ptr(nullptr) {} + msev_pointer(_Ty* ptr) : m_ptr(ptr) {} + msev_pointer(const msev_pointer<_Ty>& src) : m_ptr(src.m_ptr) {} + + _Ty& operator*() const { +#ifndef MSE_DISABLE_MSEAR_POINTER_CHECKS + if (nullptr == m_ptr) { MSE_THROW(msevector_null_dereference_error("attempt to dereference null pointer - mse::msev_pointer")); } +#endif /*MSE_DISABLE_MSEAR_POINTER_CHECKS*/ + return (*m_ptr); + } + _Ty* operator->() const { +#ifndef MSE_DISABLE_MSEAR_POINTER_CHECKS + if (nullptr == m_ptr) { MSE_THROW(msevector_null_dereference_error("attempt to dereference null pointer - mse::msev_pointer")); } +#endif /*MSE_DISABLE_MSEAR_POINTER_CHECKS*/ + return m_ptr; + } + msev_pointer<_Ty>& operator=(_Ty* ptr) { + m_ptr = ptr; + return (*this); + } + bool operator==(const msev_pointer _Right_cref) const { return (_Right_cref.m_ptr == m_ptr); } + bool operator!=(const msev_pointer _Right_cref) const { return (!((*this) == _Right_cref)); } + bool operator==(const _Ty* _Right_cref) const { return (_Right_cref == m_ptr); } + bool operator!=(const _Ty* _Right_cref) const { return (!((*this) == _Right_cref)); } + + bool operator!() const { return (!m_ptr); } + operator bool() const { return (m_ptr != nullptr); } + + operator _Ty*() const { return m_ptr; } + + _Ty* m_ptr; + }; + +#ifndef _XSTD +#define _XSTD ::std:: +#endif /*_XSTD*/ + + template<class _Ty, _Ty _Val> + struct integral_constant + { // convenient template for integral constant types + static const _Ty value = _Val; + + typedef _Ty value_type; + typedef integral_constant<_Ty, _Val> type; + + operator value_type() const + { // return stored value + return (value); + } + }; + + template<class _Iter> + struct _mse_Is_iterator + : public integral_constant<bool, !std::is_integral<_Iter>::value> + { // tests for reasonable iterator candidate + }; + template<typename _InIter> + using _mse_RequireInputIter = typename std::enable_if< + std::is_convertible<typename std::iterator_traits<_InIter>::iterator_category, std::input_iterator_tag>::value + //_mse_Is_iterator<_InIter>::value + >::type; + + /* Note that, at the moment, msevector inherits publicly from std::vector. This is not intended to be a permanent + characteristic of msevector and any reference to, or interpretation of, an msevector as an std::vector is (and has + always been) depricated. msevector endeavors to support the subset of the std::vector interface that is compatible + with the security/safety goals of msevector. (The remaining part of the std::vector interface may be supported, as a + user option, for compatibility.) + In particular, keep in mind that std::vector does not have a virtual destructor, so deallocating an msevector as an + std::vector would result in memory leaks. */ + template<class _Ty, class _A = std::allocator<_Ty> > + class msevector : public std::vector<_Ty, _A> { + public: + typedef std::vector<_Ty, _A> base_class; + typedef msevector<_Ty, _A> _Myt; + + typedef typename base_class::value_type value_type; + //typedef typename base_class::size_type size_type; + typedef msev_size_t size_type; + //typedef typename base_class::difference_type difference_type; + typedef msev_int difference_type; + typedef typename base_class::pointer pointer; + typedef typename base_class::const_pointer const_pointer; + typedef typename base_class::reference reference; + typedef typename base_class::const_reference const_reference; + + explicit msevector(const _A& _Al = _A()) + : base_class(_Al), m_mmitset(*this) { + /*m_debug_size = size();*/ + } + explicit msevector(size_type _N) + : base_class(msev_as_a_size_t(_N)), m_mmitset(*this) { + /*m_debug_size = size();*/ + } + explicit msevector(size_type _N, const _Ty& _V, const _A& _Al = _A()) + : base_class(msev_as_a_size_t(_N), _V, _Al), m_mmitset(*this) { + /*m_debug_size = size();*/ + } + msevector(base_class&& _X) : base_class(std::move(_X)), m_mmitset(*this) { /*m_debug_size = size();*/ } + msevector(const base_class& _X) : base_class(_X), m_mmitset(*this) { /*m_debug_size = size();*/ } + msevector(_Myt&& _X) : base_class(std::move(_X)), m_mmitset(*this) { /*m_debug_size = size();*/ } + msevector(const _Myt& _X) : base_class(_X), m_mmitset(*this) { /*m_debug_size = size();*/ } + typedef typename base_class::const_iterator _It; + /* Note that safety cannot be guaranteed when using these constructors that take unsafe typename base_class::iterator and/or pointer parameters. */ + msevector(_It _F, _It _L, const _A& _Al = _A()) : base_class(_F, _L, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ } + msevector(const _Ty* _F, const _Ty* _L, const _A& _Al = _A()) : base_class(_F, _L, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ } + template<class _Iter + //, class = typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type + , class = _mse_RequireInputIter<_Iter> > + msevector(_Iter _First, _Iter _Last) : base_class(_First, _Last), m_mmitset(*this) { /*m_debug_size = size();*/ } + template<class _Iter + //, class = typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type + , class = _mse_RequireInputIter<_Iter> > + //msevector(_Iter _First, _Iter _Last, const typename base_class::_Alloc& _Al) : base_class(_First, _Last, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ } + msevector(_Iter _First, _Iter _Last, const _A& _Al) : base_class(_First, _Last, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ } + _Myt& operator=(const base_class& _X) { + base_class::operator =(_X); + /*m_debug_size = size();*/ + m_mmitset.reset(); + return (*this); + } + _Myt& operator=(_Myt&& _X) { + operator=(std::move(static_cast<base_class&>(_X))); + m_mmitset.reset(); + return (*this); + } + _Myt& operator=(const _Myt& _X) { + operator=(static_cast<const base_class&>(_X)); + m_mmitset.reset(); + return (*this); + } + void reserve(size_type _Count) + { // determine new minimum length of allocated storage + auto original_capacity = msev_size_t((*this).capacity()); + + base_class::reserve(msev_as_a_size_t(_Count)); + + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + void shrink_to_fit() { // reduce capacity + auto original_capacity = msev_size_t((*this).capacity()); + + base_class::shrink_to_fit(); + + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + void resize(size_type _N, const _Ty& _X = _Ty()) { + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + bool shrinking = (_N < original_size); + + base_class::resize(msev_as_a_size_t(_N), _X); + /*m_debug_size = size();*/ + + if (shrinking) { + m_mmitset.invalidate_inclusive_range(_N, msev_size_t(original_size - 1)); + } + m_mmitset.shift_inclusive_range(original_size, original_size, msev_size_t(_N) - original_size); /*shift the end markers*/ + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + typename base_class::const_reference operator[](size_type _P) const { + return (*this).at(msev_as_a_size_t(_P)); + } + typename base_class::reference operator[](size_type _P) { + return (*this).at(msev_as_a_size_t(_P)); + } + typename base_class::reference front() { // return first element of mutable sequence + if (0 == (*this).size()) { MSE_THROW(msevector_range_error("front() on empty - typename base_class::reference front() - msevector")); } + return base_class::front(); + } + typename base_class::const_reference front() const { // return first element of nonmutable sequence + if (0 == (*this).size()) { MSE_THROW(msevector_range_error("front() on empty - typename base_class::const_reference front() - msevector")); } + return base_class::front(); + } + typename base_class::reference back() { // return last element of mutable sequence + if (0 == (*this).size()) { MSE_THROW(msevector_range_error("back() on empty - typename base_class::reference back() - msevector")); } + return base_class::back(); + } + typename base_class::const_reference back() const { // return last element of nonmutable sequence + if (0 == (*this).size()) { MSE_THROW(msevector_range_error("back() on empty - typename base_class::const_reference back() - msevector")); } + return base_class::back(); + } + void push_back(_Ty&& _X) { + if (m_mmitset.is_empty()) { + base_class::push_back(std::move(_X)); + } + else { + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + base_class::push_back(std::move(_X)); + /*m_debug_size = size();*/ + + assert((original_size + 1) == msev_size_t((*this).size())); + m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/ + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + } + void push_back(const _Ty& _X) { + if (m_mmitset.is_empty()) { + base_class::push_back(_X); + } + else { + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + base_class::push_back(_X); + /*m_debug_size = size();*/ + + assert((original_size + 1) == msev_size_t((*this).size())); + m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/ + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + } + void pop_back() { + if (m_mmitset.is_empty()) { + base_class::pop_back(); + } + else { + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + if (0 == original_size) { MSE_THROW(msevector_range_error("pop_back() on empty - void pop_back() - msevector")); } + base_class::pop_back(); + /*m_debug_size = size();*/ + + assert((original_size - 1) == msev_size_t((*this).size())); + m_mmitset.invalidate_inclusive_range(msev_size_t(original_size - 1), msev_size_t(original_size - 1)); + m_mmitset.shift_inclusive_range(original_size, original_size, -1); /*shift the end markers*/ + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + } + void assign(_It _F, _It _L) { + base_class::assign(_F, _L); + /*m_debug_size = size();*/ + m_mmitset.reset(); + } + template<class _Iter> + void assign(_Iter _First, _Iter _Last) { // assign [_First, _Last) + base_class::assign(_First, _Last); + /*m_debug_size = size();*/ + m_mmitset.reset(); + } + void assign(size_type _N, const _Ty& _X = _Ty()) { + base_class::assign(msev_as_a_size_t(_N), _X); + /*m_debug_size = size();*/ + m_mmitset.reset(); + } + typename base_class::iterator insert(typename base_class::const_iterator _P, _Ty&& _X) { + return (emplace(_P, std::move(_X))); + } + typename base_class::iterator insert(typename base_class::const_iterator _P, const _Ty& _X = _Ty()) { + if (m_mmitset.is_empty()) { + typename base_class::iterator retval = base_class::insert(_P, _X); + /*m_debug_size = size();*/ + return retval; + } + else { + msev_int di = std::distance(base_class::cbegin(), _P); + msev_size_t d = msev_size_t(di); + if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + typename base_class::iterator retval = base_class::insert(_P, _X); + /*m_debug_size = size();*/ + + assert((original_size + 1) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + m_mmitset.shift_inclusive_range(d, original_size, 1); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } + +#if !(defined(GPP4P8_COMPATIBLE)) + typename base_class::iterator insert(typename base_class::const_iterator _P, size_type _M, const _Ty& _X) { + if (m_mmitset.is_empty()) { + typename base_class::iterator retval = base_class::insert(_P, msev_as_a_size_t(_M), _X); + /*m_debug_size = size();*/ + return retval; + } + else { + msev_int di = std::distance(base_class::cbegin(), _P); + msev_size_t d = msev_size_t(di); + if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + typename base_class::iterator retval = base_class::insert(_P, msev_as_a_size_t(_M), _X); + /*m_debug_size = size();*/ + + assert((original_size + _M) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + m_mmitset.shift_inclusive_range(d, original_size, msev_int(_M)); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + typename base_class::iterator insert(typename base_class::const_iterator _Where, _Iter _First, _Iter _Last) { // insert [_First, _Last) at _Where + if (m_mmitset.is_empty()) { + auto retval = base_class::insert(_Where, _First, _Last); + /*m_debug_size = size();*/ + return retval; + } + else { + msev_int di = std::distance(base_class::cbegin(), _Where); + msev_size_t d = msev_size_t(di); + if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto _M = msev_int(std::distance(_First, _Last)); + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + //if (0 > _M) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator insert() - msevector")); } + auto retval = base_class::insert(_Where, _First, _Last); + /*m_debug_size = size();*/ + + assert((original_size + _M) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + m_mmitset.shift_inclusive_range(d, original_size, _M); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } + +#else /*!(defined(GPP4P8_COMPATIBLE))*/ + + /*typename base_class::iterator*/ + void + /* g++4.8 seems to be using the c++98 version of this insert function instead of the c++11 version. */ + insert(typename base_class::/*const_*/iterator _P, size_t _M, const _Ty& _X) { + msev_int di = std::distance(base_class::/*c*/begin(), _P); + msev_size_t d = msev_size_t(di); + if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + /*typename base_class::iterator retval =*/ + base_class::insert(_P, _M, _X); + /*m_debug_size = size();*/ + + assert((original_size + _M) == msev_size_t((*this).size())); + /*assert(di == std::distance(base_class::begin(), retval));*/ + m_mmitset.shift_inclusive_range(d, original_size, _M); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + /*return retval;*/ + } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type + , class = _mse_RequireInputIter<_Iter> > void + insert(typename base_class::/*const_*/iterator _Where, _Iter _First, _Iter _Last) { // insert [_First, _Last) at _Where + msev_int di = std::distance(base_class::/*c*/begin(), _Where); + msev_size_t d = msev_size_t(di); + if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto _M = msev_int(std::distance(_First, _Last)); + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + //if (0 > _M) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator insert() - msevector")); } + /*auto retval =*/ + base_class::insert(_Where, _First, _Last); + /*m_debug_size = size();*/ + + assert((original_size + _M) == msev_size_t((*this).size())); + /*assert(di == std::distance(base_class::begin(), retval));*/ + m_mmitset.shift_inclusive_range(d, original_size, _M); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + /*return retval;*/ + } +#endif /*!(defined(GPP4P8_COMPATIBLE))*/ + + template<class ..._Valty> + void emplace_back(_Valty&& ..._Val) + { // insert by moving into element at end + if (m_mmitset.is_empty()) { + base_class::emplace_back(std::forward<_Valty>(_Val)...); + /*m_debug_size = size();*/ + } + else { + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + base_class::emplace_back(std::forward<_Valty>(_Val)...); + /*m_debug_size = size();*/ + + assert((original_size + 1) == msev_size_t((*this).size())); + m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/ + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + } + } + template<class ..._Valty> +#if !(defined(GPP4P8_COMPATIBLE)) + typename base_class::iterator emplace(typename base_class::const_iterator _Where, _Valty&& ..._Val) + { // insert by moving _Val at _Where +#else /*!(defined(GPP4P8_COMPATIBLE))*/ + typename base_class::iterator emplace(typename base_class::/*const_*/iterator _Where, _Valty&& ..._Val) + { // insert by moving _Val at _Where +#endif /*!(defined(GPP4P8_COMPATIBLE))*/ + + if (m_mmitset.is_empty()) { + auto retval = base_class::emplace(_Where, std::forward<_Valty>(_Val)...); + /*m_debug_size = size();*/ + return retval; + } + else { + +#if !(defined(GPP4P8_COMPATIBLE)) + msev_int di = std::distance(base_class::cbegin(), _Where); +#else /*!(defined(GPP4P8_COMPATIBLE))*/ + msev_int di = std::distance(base_class::/*c*/begin(), _Where); +#endif /*!(defined(GPP4P8_COMPATIBLE))*/ + + msev_size_t d = msev_size_t(di); + if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator emplace() - msevector")); } + + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + auto retval = base_class::emplace(_Where, std::forward<_Valty>(_Val)...); + /*m_debug_size = size();*/ + + assert((original_size + 1) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + m_mmitset.shift_inclusive_range(d, original_size, 1); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } + typename base_class::iterator erase(typename base_class::const_iterator _P) { + if (m_mmitset.is_empty()) { + typename base_class::iterator retval = base_class::erase(_P); + /*m_debug_size = size();*/ + return retval; + } + else { + msev_int di = std::distance(base_class::cbegin(), _P); + msev_size_t d = msev_size_t(di); + if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); } + + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + if (base_class::end() == _P) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator erase(typename base_class::const_iterator _P) - msevector")); } + typename base_class::iterator retval = base_class::erase(_P); + /*m_debug_size = size();*/ + + assert((original_size - 1) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + { + m_mmitset.invalidate_inclusive_range(d, d); + m_mmitset.shift_inclusive_range(msev_size_t(d + 1), original_size, -1); + } + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } + typename base_class::iterator erase(typename base_class::const_iterator _F, typename base_class::const_iterator _L) { + if (m_mmitset.is_empty()) { + typename base_class::iterator retval = base_class::erase(_F, _L); + /*m_debug_size = size();*/ + return retval; + } + else { + msev_int di = std::distance(base_class::cbegin(), _F); + msev_size_t d = msev_size_t(di); + if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); } + msev_int di2 = std::distance(base_class::cbegin(), _L); + msev_size_t d2 = msev_size_t(di2); + if ((0 > di2) || ((*this).size() < msev_size_t(di2))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); } + + auto _M = msev_int(std::distance(_F, _L)); + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + 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")); } + typename base_class::iterator retval = base_class::erase(_F, _L); + /*m_debug_size = size();*/ + + assert((original_size - _M) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + { + if (1 <= _M) { + m_mmitset.invalidate_inclusive_range(d, msev_size_t(d + _M - 1)); + } + m_mmitset.shift_inclusive_range(msev_size_t(d + _M), original_size, -_M); + } + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } + void clear() { + base_class::clear(); + /*m_debug_size = size();*/ + m_mmitset.reset(); + } + void swap(base_class& _X) { + base_class::swap(_X); + /*m_debug_size = size();*/ + m_mmitset.reset(); + } + void swap(_Myt& _X) { + swap(static_cast<base_class&>(_X)); + m_mmitset.reset(); + } + + msevector(_XSTD initializer_list<typename base_class::value_type> _Ilist, + const _A& _Al = _A()) + : base_class(_Ilist, _Al), m_mmitset(*this) { // construct from initializer_list + /*m_debug_size = size();*/ + } + _Myt& operator=(_XSTD initializer_list<typename base_class::value_type> _Ilist) { // assign initializer_list + operator=(static_cast<base_class>(_Ilist)); + m_mmitset.reset(); + return (*this); + } + void assign(_XSTD initializer_list<typename base_class::value_type> _Ilist) { // assign initializer_list + base_class::assign(_Ilist); + /*m_debug_size = size();*/ + m_mmitset.reset(); + } +#if defined(GPP4P8_COMPATIBLE) + /* g++4.8 seems to be (incorrectly) using the c++98 version of this insert function instead of the c++11 version. */ + /*typename base_class::iterator*/void insert(typename base_class::/*const_*/iterator _Where, _XSTD initializer_list<typename base_class::value_type> _Ilist) { // insert initializer_list + msev_int di = std::distance(base_class::/*c*/begin(), _Where); + msev_size_t d = msev_size_t(di); + if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto _M = _Ilist.size(); + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + /*auto retval = */base_class::insert(_Where, _Ilist); + /*m_debug_size = size();*/ + + assert((original_size + _M) == msev_size_t((*this).size())); + /*assert(di == std::distance(base_class::begin(), retval));*/ + m_mmitset.shift_inclusive_range(d, original_size, _M); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + /*return retval;*/ + } +#else /*defined(GPP4P8_COMPATIBLE)*/ + typename base_class::iterator insert(typename base_class::const_iterator _Where, _XSTD initializer_list<typename base_class::value_type> _Ilist) { // insert initializer_list + if (m_mmitset.is_empty()) { + auto retval = base_class::insert(_Where, _Ilist); + /*m_debug_size = size();*/ + return retval; + } + else { + msev_int di = std::distance(base_class::cbegin(), _Where); + msev_size_t d = msev_size_t(di); + if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); } + + auto _M = _Ilist.size(); + auto original_size = msev_size_t((*this).size()); + auto original_capacity = msev_size_t((*this).capacity()); + + auto retval = base_class::insert(_Where, _Ilist); + /*m_debug_size = size();*/ + + assert((original_size + _M) == msev_size_t((*this).size())); + assert(di == std::distance(base_class::begin(), retval)); + m_mmitset.shift_inclusive_range(d, original_size, msev_int(_M)); + auto new_capacity = msev_size_t((*this).capacity()); + bool realloc_occured = (new_capacity != original_capacity); + if (realloc_occured) { + m_mmitset.sync_iterators_to_index(); + } + return retval; + } + } +#endif /*defined(GPP4P8_COMPATIBLE)*/ + + //size_t m_debug_size; + + class random_access_const_iterator_base : public std::iterator<std::random_access_iterator_tag, value_type, difference_type, const_pointer, const_reference> {}; + class random_access_iterator_base : public std::iterator<std::random_access_iterator_tag, value_type, difference_type, pointer, reference> {}; + + /* mm_const_iterator_type acts much like a list iterator. */ + class mm_const_iterator_type : public random_access_const_iterator_base { + public: + typedef typename base_class::const_iterator::iterator_category iterator_category; + typedef typename base_class::const_iterator::value_type value_type; + //typedef typename base_class::const_iterator::difference_type difference_type; + typedef msev_int difference_type; + typedef difference_type distance_type; // retained + typedef typename base_class::const_iterator::pointer pointer; + typedef typename base_class::const_iterator::pointer const_pointer; + typedef typename base_class::const_iterator::reference reference; + typedef typename base_class::const_reference const_reference; + + void reset() { set_to_end_marker(); } + bool points_to_an_item() const { + if (m_points_to_an_item) { assert((1 <= m_owner_cptr->size()) && (m_index < m_owner_cptr->size())); return true; } + else { assert(!((1 <= m_owner_cptr->size()) && (m_index < m_owner_cptr->size()))); return false; } + } + bool points_to_end_marker() const { + if (false == points_to_an_item()) { assert(m_index == m_owner_cptr->size()); return true; } + else { return false; } + } + bool points_to_beginning() const { + if (0 == m_index) { return true; } + else { return false; } + } + /* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */ + bool has_next_item_or_end_marker() const { return points_to_an_item(); } //his is + /* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */ + bool has_next() const { return has_next_item_or_end_marker(); } + bool has_previous() const { return (!points_to_beginning()); } + void set_to_beginning() { + m_index = 0; + if (1 <= m_owner_cptr->size()) { + m_points_to_an_item = true; + } + else { assert(false == m_points_to_an_item); } + } + void set_to_end_marker() { + m_index = m_owner_cptr->size(); + m_points_to_an_item = false; + } + void set_to_next() { + if (points_to_an_item()) { + m_index += 1; + if (m_owner_cptr->size() <= m_index) { + (*this).m_points_to_an_item = false; + if (m_owner_cptr->size() < m_index) { assert(false); reset(); } + } + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_next() - mm_const_iterator_type - msevector")); + } + } + void set_to_previous() { + if (has_previous()) { + m_index -= 1; + (*this).m_points_to_an_item = true; + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_previous() - mm_const_iterator_type - msevector")); + } + } + mm_const_iterator_type& operator ++() { (*this).set_to_next(); return (*this); } + mm_const_iterator_type operator++(int) { mm_const_iterator_type _Tmp = *this; ++*this; return (_Tmp); } + mm_const_iterator_type& operator --() { (*this).set_to_previous(); return (*this); } + mm_const_iterator_type operator--(int) { mm_const_iterator_type _Tmp = *this; --*this; return (_Tmp); } + void advance(difference_type n) { + auto new_index = msev_int(m_index) + n; + if ((0 > new_index) || (m_owner_cptr->size() < msev_size_t(new_index))) { + MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - mm_const_iterator_type - msevector")); + } + else { + m_index = msev_size_t(new_index); + if (m_owner_cptr->size() <= m_index) { + (*this).m_points_to_an_item = false; + } + else { + (*this).m_points_to_an_item = true; + } + } + } + void regress(difference_type n) { advance(-n); } + mm_const_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); } + mm_const_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); } + mm_const_iterator_type operator+(difference_type n) const { + mm_const_iterator_type retval(*this); + retval = (*this); + retval.advance(n); + return retval; + } + mm_const_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); } + difference_type operator-(const mm_const_iterator_type &rhs) const { + if ((rhs.m_owner_cptr) != ((*this).m_owner_cptr)) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const mm_const_iterator_type &rhs) const - msevector::mm_const_iterator_type")); } + auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index); + assert(difference_type(m_owner_cptr->size()) >= retval); + return retval; + } + const_reference operator*() const { + return m_owner_cptr->at(msev_as_a_size_t(m_index)); + } + const_reference item() const { return operator*(); } + const_reference previous_item() const { + return m_owner_cptr->at(msev_as_a_size_t(m_index - 1)); + } + const_pointer operator->() const { + return &(m_owner_cptr->at(msev_as_a_size_t(m_index))); + } + const_reference operator[](difference_type _Off) const { return (*m_owner_cptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); } + /* + mm_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref) + { + msev_int d = std::distance<typename base_class::iterator>(m_owner_cptr->cbegin(), _Right_cref); + if ((0 <= d) && (m_owner_cptr->size() >= d)) { + if (m_owner_cptr->size() == d) { + assert(m_owner_cptr->cend() == _Right_cref); + m_points_to_an_item = false; + } else { + m_points_to_an_item = true; + } + m_index = msev_size_t(d); + base_class::const_iterator::operator=(_Right_cref); + } + else { + MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref) - mm_const_iterator_type - msevector")); + } + return (*this); + } + */ + mm_const_iterator_type& operator=(const mm_const_iterator_type& _Right_cref) + { + if (((*this).m_owner_cptr) == (_Right_cref.m_owner_cptr)) { + assert((*this).m_owner_cptr->size() >= _Right_cref.m_index); + (*this).m_points_to_an_item = _Right_cref.m_points_to_an_item; + (*this).m_index = _Right_cref.m_index; + } + else { + MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_const_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - mm_const_iterator_type - msevector")); + } + return (*this); + } + bool operator==(const mm_const_iterator_type& _Right_cref) const { + if (((*this).m_owner_cptr) != (_Right_cref.m_owner_cptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_const_iterator_type& operator==(const mm_const_iterator_type& _Right) - mm_const_iterator_type - msevector")); } + return (_Right_cref.m_index == m_index); + } + bool operator!=(const mm_const_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); } + bool operator<(const mm_const_iterator_type& _Right) const { + if (((*this).m_owner_cptr) != (_Right.m_owner_cptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_const_iterator_type& operator<(const mm_const_iterator_type& _Right) - mm_const_iterator_type - msevector")); } + return (m_index < _Right.m_index); + } + bool operator<=(const mm_const_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); } + bool operator>(const mm_const_iterator_type& _Right) const { return (!((*this) <= _Right)); } + bool operator>=(const mm_const_iterator_type& _Right) const { return (!((*this) < _Right)); } + void set_to_const_item_pointer(const mm_const_iterator_type& _Right_cref) { + (*this) = _Right_cref; + } + void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + (*this).reset(); + } + } + void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + auto new_index = (*this).m_index + shift; + if ((0 > new_index) || (m_owner_cptr->size() < new_index)) { + MSE_THROW(msevector_range_error("void shift_inclusive_range() - mm_const_iterator_type - msevector")); + } + else { + (*this).m_index = msev_size_t(new_index); + (*this).sync_const_iterator_to_index(); + } + } + } + msev_size_t position() const { + return m_index; + } + operator typename base_class::const_iterator() const { + typename base_class::const_iterator retval = (*m_owner_cptr).cbegin(); + retval += msev_as_a_size_t(m_index); + return retval; + } + + /* We actually want to make this constructor private, but doing so seems to break std::make_shared<mm_const_iterator_type>. */ + mm_const_iterator_type(const _Myt& owner_cref) : m_owner_cptr(&owner_cref) { set_to_beginning(); } + private: + mm_const_iterator_type(const mm_const_iterator_type& src_cref) : m_owner_cptr(src_cref.m_owner_cptr) { (*this) = src_cref; } + void sync_const_iterator_to_index() { + assert(m_owner_cptr->size() >= (*this).m_index); + } + msev_bool m_points_to_an_item = false; + msev_size_t m_index = 0; + const _Myt* m_owner_cptr = nullptr; + friend class mm_iterator_set_type; + friend class /*_Myt*/msevector<_Ty, _A>; + friend class mm_iterator_type; + }; + /* mm_iterator_type acts much like a list iterator. */ + class mm_iterator_type : random_access_iterator_base { + public: + typedef typename base_class::iterator::iterator_category iterator_category; + typedef typename base_class::iterator::value_type value_type; + //typedef typename base_class::iterator::difference_type difference_type; + typedef msev_int difference_type; + typedef difference_type distance_type; // retained + typedef typename base_class::iterator::pointer pointer; + typedef typename base_class::iterator::reference reference; + + void reset() { set_to_end_marker(); } + bool points_to_an_item() const { + if (m_points_to_an_item) { assert((1 <= m_owner_ptr->size()) && (m_index < m_owner_ptr->size())); return true; } + else { assert(!((1 <= m_owner_ptr->size()) && (m_index < m_owner_ptr->size()))); return false; } + } + bool points_to_end_marker() const { + if (false == points_to_an_item()) { assert(m_index == m_owner_ptr->size()); return true; } + else { return false; } + } + bool points_to_beginning() const { + if (0 == m_index) { return true; } + else { return false; } + } + /* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */ + bool has_next_item_or_end_marker() const { return points_to_an_item(); } + /* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */ + bool has_next() const { return has_next_item_or_end_marker(); } + bool has_previous() const { return (!points_to_beginning()); } + void set_to_beginning() { + m_index = 0; + if (1 <= m_owner_ptr->size()) { + m_points_to_an_item = true; + } + else { assert(false == m_points_to_an_item); } + } + void set_to_end_marker() { + m_index = m_owner_ptr->size(); + m_points_to_an_item = false; + } + void set_to_next() { + if (points_to_an_item()) { + m_index += 1; + if (m_owner_ptr->size() <= m_index) { + (*this).m_points_to_an_item = false; + if (m_owner_ptr->size() < m_index) { assert(false); reset(); } + } + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_next() - mm_const_iterator_type - msevector")); + } + } + void set_to_previous() { + if (has_previous()) { + m_index -= 1; + (*this).m_points_to_an_item = true; + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_previous() - mm_iterator_type - msevector")); + } + } + mm_iterator_type& operator ++() { (*this).set_to_next(); return (*this); } + mm_iterator_type operator++(int) { mm_iterator_type _Tmp = *this; ++*this; return (_Tmp); } + mm_iterator_type& operator --() { (*this).set_to_previous(); return (*this); } + mm_iterator_type operator--(int) { mm_iterator_type _Tmp = *this; --*this; return (_Tmp); } + void advance(difference_type n) { + auto new_index = msev_int(m_index) + n; + if ((0 > new_index) || (m_owner_ptr->size() < msev_size_t(new_index))) { + MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - mm_iterator_type - msevector")); + } + else { + m_index = msev_size_t(new_index); + if (m_owner_ptr->size() <= m_index) { + (*this).m_points_to_an_item = false; + } + else { + (*this).m_points_to_an_item = true; + } + } + } + void regress(int n) { advance(-n); } + mm_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); } + mm_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); } + mm_iterator_type operator+(difference_type n) const { + mm_iterator_type retval(*this); + retval = (*this); + retval.advance(n); + return retval; + } + mm_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); } + difference_type operator-(const mm_iterator_type& rhs) const { + if ((rhs.m_owner_ptr) != ((*this).m_owner_ptr)) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const mm_iterator_type& rhs) const - msevector::mm_iterator_type")); } + auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index); + assert(difference_type(m_owner_ptr->size()) >= retval); + return retval; + } + reference operator*() const { + return m_owner_ptr->at(msev_as_a_size_t(m_index)); + } + reference item() const { return operator*(); } + reference previous_item() const { + return m_owner_ptr->at(msev_as_a_size_t(m_index - 1)); + } + pointer operator->() const { + return &(m_owner_ptr->at(msev_as_a_size_t(m_index))); + } + reference operator[](difference_type _Off) const { return (*m_owner_ptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); } + /* + mm_iterator_type& operator=(const typename base_class::iterator& _Right_cref) + { + msev_int d = std::distance<typename base_class::iterator>(m_owner_ptr->begin(), _Right_cref); + if ((0 <= d) && (m_owner_ptr->size() >= d)) { + if (m_owner_ptr->size() == d) { + assert(m_owner_ptr->end() == _Right_cref); + m_points_to_an_item = false; + } else { + m_points_to_an_item = true; + } + m_index = msev_size_t(d); + base_class::iterator::operator=(_Right_cref); + } + else { + MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - mm_const_iterator_type - msevector")); + } + return (*this); + } + */ + mm_iterator_type& operator=(const mm_iterator_type& _Right_cref) + { + if (((*this).m_owner_ptr) == (_Right_cref.m_owner_ptr)) { + assert((*this).m_owner_ptr->size() >= _Right_cref.m_index); + (*this).m_points_to_an_item = _Right_cref.m_points_to_an_item; + (*this).m_index = _Right_cref.m_index; + } + else { + MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - mm_const_iterator_type - msevector")); + } + return (*this); + } + bool operator==(const mm_iterator_type& _Right_cref) const { + if (((*this).m_owner_ptr) != (_Right_cref.m_owner_ptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_iterator_type& operator==(const typename base_class::iterator& _Right) - mm_iterator_type - msevector")); } + return (_Right_cref.m_index == m_index); + } + bool operator!=(const mm_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); } + bool operator<(const mm_iterator_type& _Right) const { + if (((*this).m_owner_ptr) != (_Right.m_owner_ptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_iterator_type& operator<(const typename base_class::iterator& _Right) - mm_iterator_type - msevector")); } + return (m_index < _Right.m_index); + } + bool operator<=(const mm_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); } + bool operator>(const mm_iterator_type& _Right) const { return (!((*this) <= _Right)); } + bool operator>=(const mm_iterator_type& _Right) const { return (!((*this) < _Right)); } + void set_to_item_pointer(const mm_iterator_type& _Right_cref) { + (*this) = _Right_cref; + } + void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + (*this).reset(); + } + } + void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + auto new_index = (*this).m_index + shift; + if ((0 > new_index) || (m_owner_ptr->size() < new_index)) { + MSE_THROW(msevector_range_error("void shift_inclusive_range() - mm_iterator_type - msevector")); + } + else { + (*this).m_index = msev_size_t(new_index); + (*this).sync_iterator_to_index(); + } + } + } + msev_size_t position() const { + return m_index; + } + operator mm_const_iterator_type() const { + mm_const_iterator_type retval(*m_owner_ptr); + retval.set_to_beginning(); + retval.advance(msev_int(m_index)); + return retval; + } + /* We actually want to make this constructor private, but doing so seems to break std::make_shared<mm_iterator_type>. */ + mm_iterator_type(_Myt& owner_ref) : m_owner_ptr(&owner_ref) { set_to_beginning(); } + private: + mm_iterator_type(const mm_iterator_type& src_cref) : m_owner_ptr(src_cref.m_owner_ptr) { (*this) = src_cref; } + void sync_iterator_to_index() { + assert(m_owner_ptr->size() >= (*this).m_index); + } + msev_bool m_points_to_an_item = false; + msev_size_t m_index = 0; + _Myt* m_owner_ptr = nullptr; + friend class mm_iterator_set_type; + friend class /*_Myt*/msevector<_Ty, _A>; + }; + + private: + typedef std::size_t CHashKey1; + class mm_const_iterator_handle_type { + public: + mm_const_iterator_handle_type(const CHashKey1& key_cref, const std::shared_ptr<mm_const_iterator_type>& shptr_cref) : m_shptr(shptr_cref), m_key(key_cref) {} + private: + std::shared_ptr<mm_const_iterator_type> m_shptr; + CHashKey1 m_key; + friend class /*_Myt*/msevector<_Ty, _A>; + friend class mm_iterator_set_type; + }; + class mm_iterator_handle_type { + public: + mm_iterator_handle_type(const CHashKey1& key_cref, const std::shared_ptr<mm_iterator_type>& shptr_ref) : m_shptr(shptr_ref), m_key(key_cref) {} + private: + std::shared_ptr<mm_iterator_type> m_shptr; + CHashKey1 m_key; + friend class /*_Myt*/msevector<_Ty, _A>; + friend class mm_iterator_set_type; + }; + + class mm_iterator_set_type { + public: + class CMMConstIterators : public std::unordered_map<CHashKey1, std::shared_ptr<mm_const_iterator_type>> {}; + class CMMIterators : public std::unordered_map<CHashKey1, std::shared_ptr<mm_iterator_type>> {}; + + class assignable_CMMConstIterators_value_type : public std::pair<CHashKey1, std::shared_ptr<mm_const_iterator_type>> { + public: + assignable_CMMConstIterators_value_type() {} + assignable_CMMConstIterators_value_type(const typename CMMConstIterators::value_type& src) : std::pair<CHashKey1, std::shared_ptr<mm_iterator_type>>(src.first, src.second) {} + assignable_CMMConstIterators_value_type& operator=(const typename CMMConstIterators::value_type& rhs) { (*this).first = rhs.first; (*this).second = rhs.second; return (*this); } + operator typename CMMConstIterators::value_type() const { return CMMConstIterators::value_type((*this).first, (*this).second); } + }; + class assignable_CMMIterators_value_type : public std::pair<CHashKey1, std::shared_ptr<mm_iterator_type>> { + public: + assignable_CMMIterators_value_type() {} + assignable_CMMIterators_value_type(const typename CMMIterators::value_type& src) : std::pair<CHashKey1, std::shared_ptr<mm_iterator_type>>(src.first, src.second) {} + assignable_CMMIterators_value_type& operator=(const typename CMMIterators::value_type& rhs) { (*this).first = rhs.first; (*this).second = rhs.second; return (*this); } + operator typename CMMIterators::value_type() const { return CMMIterators::value_type((*this).first, (*this).second); } + }; + + ~mm_iterator_set_type() { + if (!mm_const_fast_mode1()) { + delete m_aux_mm_const_iterator_shptrs_ptr; + } + if (!mm_fast_mode1()) { + delete m_aux_mm_iterator_shptrs_ptr; + } + } + + void apply_to_all_mm_const_iterator_shptrs(const std::function<void(std::shared_ptr<mm_const_iterator_type>&)>& func_obj_ref) { + if (!mm_const_fast_mode1()) { + for (auto it = (*m_aux_mm_const_iterator_shptrs_ptr).begin(); (*m_aux_mm_const_iterator_shptrs_ptr).end() != it; it++) { + func_obj_ref((*it).second); + } + } + else { + for (int i = 0; i < m_fm1_num_mm_const_iterators; i += 1) { + func_obj_ref(m_fm1_key_mm_const_it_array[i].second); + } + } + } + void apply_to_all_mm_iterator_shptrs(const std::function<void(std::shared_ptr<mm_iterator_type>&)>& func_obj_ref) { + if (!mm_fast_mode1()) { + for (auto it = (*m_aux_mm_iterator_shptrs_ptr).begin(); (*m_aux_mm_iterator_shptrs_ptr).end() != it; it++) { + func_obj_ref((*it).second); + } + } + else { + for (int i = 0; i < m_fm1_num_mm_iterators; i += 1) { + func_obj_ref(m_fm1_key_mm_it_array[i].second); + } + } + } + mm_iterator_set_type(_Myt& owner_ref) : m_next_available_key(0), m_owner_ptr(&owner_ref) {} + void reset() { + /* We can use "static" here because the lambda function does not capture any parameters. */ + static const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [](std::shared_ptr<mm_const_iterator_type>& a) { a->reset(); }; + apply_to_all_mm_const_iterator_shptrs(cit_func_obj); + static const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [](std::shared_ptr<mm_iterator_type>& a) { a->reset(); }; + apply_to_all_mm_iterator_shptrs(it_func_obj); + } + void sync_iterators_to_index() { + /* No longer used. Relic from when mm_iterator_type contained a "native" iterator. */ + /* We can use "static" here because the lambda function does not capture any parameters. */ + /* + static const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [](std::shared_ptr<mm_const_iterator_type>& a) { a->sync_const_iterator_to_index(); }; + apply_to_all_mm_const_iterator_shptrs(cit_func_obj); + static const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [](std::shared_ptr<mm_iterator_type>& a) { a->sync_iterator_to_index(); }; + apply_to_all_mm_iterator_shptrs(it_func_obj); + */ + } + void invalidate_inclusive_range(msev_size_t start_index, msev_size_t end_index) { + const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [start_index, end_index](std::shared_ptr<mm_const_iterator_type>& a) { a->invalidate_inclusive_range(start_index, end_index); }; + apply_to_all_mm_const_iterator_shptrs(cit_func_obj); + const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [start_index, end_index](std::shared_ptr<mm_iterator_type>& a) { a->invalidate_inclusive_range(start_index, end_index); }; + apply_to_all_mm_iterator_shptrs(it_func_obj); + } + void shift_inclusive_range(msev_size_t start_index, msev_size_t end_index, msev_int shift) { + const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [start_index, end_index, shift](std::shared_ptr<mm_const_iterator_type>& a) { a->shift_inclusive_range(start_index, end_index, shift); }; + apply_to_all_mm_const_iterator_shptrs(cit_func_obj); + const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [start_index, end_index, shift](std::shared_ptr<mm_iterator_type>& a) { a->shift_inclusive_range(start_index, end_index, shift); }; + apply_to_all_mm_iterator_shptrs(it_func_obj); + } + bool is_empty() const { + if (mm_const_fast_mode1()) { + if (1 <= m_fm1_num_mm_const_iterators) { + return false; + } + } + else { + if (1 <= m_aux_mm_const_iterator_shptrs_ptr->size()) { + return false; + } + } + if (mm_fast_mode1()) { + if (1 <= m_fm1_num_mm_iterators) { + return false; + } + } + else { + if (1 <= m_aux_mm_iterator_shptrs_ptr->size()) { + return false; + } + } + return true; + } + + mm_const_iterator_handle_type allocate_new_const_item_pointer() { + //auto shptr = std::shared_ptr<mm_const_iterator_type>(new mm_const_iterator_type(*m_owner_ptr)); + auto shptr = std::make_shared<mm_const_iterator_type>(*m_owner_ptr); + auto key = m_next_available_key; m_next_available_key++; + mm_const_iterator_handle_type retval(key, shptr); + typename CMMConstIterators::value_type new_item(key, shptr); + if (!mm_const_fast_mode1()) { + (*m_aux_mm_const_iterator_shptrs_ptr).insert(new_item); + } else { + if (sc_fm1_max_mm_iterators == m_fm1_num_mm_const_iterators) { + /* Too many items. Initiate and switch to slow mode. */ + /* Initialize slow storage. */ + m_aux_mm_const_iterator_shptrs_ptr = new CMMConstIterators(); + /* First copy the items from fast storage to slow storage. */ + for (int i = 0; i < sc_fm1_max_mm_iterators; i += 1) { + (*m_aux_mm_const_iterator_shptrs_ptr).insert(m_fm1_key_mm_const_it_array[i]); + } + /* Add the new items to slow storage. */ + (*m_aux_mm_const_iterator_shptrs_ptr).insert(new_item); + } + else { + m_fm1_key_mm_const_it_array[m_fm1_num_mm_const_iterators] = new_item; + m_fm1_num_mm_const_iterators += 1; + } + } + return retval; + } + void release_const_item_pointer(mm_const_iterator_handle_type handle) { + if (!mm_const_fast_mode1()) { + auto it = (*m_aux_mm_const_iterator_shptrs_ptr).find(handle.m_key); + if ((*m_aux_mm_const_iterator_shptrs_ptr).end() != it) { + (*m_aux_mm_const_iterator_shptrs_ptr).erase(it); + } + else { + /* Do we need to throw here? */ + MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_const_iterator(mm_const_iterator_handle_type handle) - msevector::mm_iterator_set_type")); + } + } + else { + int found_index = -1; + for (int i = 0; i < m_fm1_num_mm_const_iterators; i += 1) { + if (handle.m_key == m_fm1_key_mm_const_it_array[i].first) { + found_index = i; + break; + } + } + if (0 <= found_index) { + m_fm1_num_mm_const_iterators -= 1; + assert(0 <= m_fm1_num_mm_const_iterators); + for (int j = found_index; j < m_fm1_num_mm_const_iterators; j += 1) { + m_fm1_key_mm_const_it_array[j] = m_fm1_key_mm_const_it_array[j + 1]; + } + } + else { + /* Do we need to throw here? */ + MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_const_iterator(mm_const_iterator_handle_type handle) - msevector::mm_iterator_set_type")); + } + } + } + + mm_iterator_handle_type allocate_new_item_pointer() { + //auto shptr = std::shared_ptr<mm_iterator_type>(new mm_iterator_type(*m_owner_ptr)); + auto shptr = std::make_shared<mm_iterator_type>(*m_owner_ptr); + auto key = m_next_available_key; m_next_available_key++; + mm_iterator_handle_type retval(key, shptr); + typename CMMIterators::value_type new_item(key, shptr); + if (!mm_fast_mode1()) { + (*m_aux_mm_iterator_shptrs_ptr).insert(new_item); + } + else { + if (sc_fm1_max_mm_iterators == m_fm1_num_mm_iterators) { + /* Too many items. Initiate and switch to slow mode. */ + /* Initialize slow storage. */ + m_aux_mm_iterator_shptrs_ptr = new CMMIterators(); + /* First copy the items from fast storage to slow storage. */ + for (int i = 0; i < sc_fm1_max_mm_iterators; i += 1) { + (*m_aux_mm_iterator_shptrs_ptr).insert(m_fm1_key_mm_it_array[i]); + } + /* Add the new items to slow storage. */ + (*m_aux_mm_iterator_shptrs_ptr).insert(new_item); + } + else { + m_fm1_key_mm_it_array[m_fm1_num_mm_iterators] = new_item; + m_fm1_num_mm_iterators += 1; + } + } + return retval; + } + void release_item_pointer(mm_iterator_handle_type handle) { + if (!mm_fast_mode1()) { + auto it = (*m_aux_mm_iterator_shptrs_ptr).find(handle.m_key); + if ((*m_aux_mm_iterator_shptrs_ptr).end() != it) { + (*m_aux_mm_iterator_shptrs_ptr).erase(it); + } + else { + /* Do we need to throw here? */ + MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_iterator(mm_iterator_handle_type handle) - msevector::mm_iterator_set_type")); + } + } + else { + int found_index = -1; + for (int i = 0; i < m_fm1_num_mm_iterators; i += 1) { + if (handle.m_key == m_fm1_key_mm_it_array[i].first) { + found_index = i; + break; + } + } + if (0 <= found_index) { + m_fm1_num_mm_iterators -= 1; + assert(0 <= m_fm1_num_mm_iterators); + for (int j = found_index; j < m_fm1_num_mm_iterators; j += 1) { + m_fm1_key_mm_it_array[j] = m_fm1_key_mm_it_array[j + 1]; + } + } + else { + /* Do we need to throw here? */ + MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_iterator(mm_iterator_handle_type handle) - msevector::mm_iterator_set_type")); + } + } + } + void release_all_item_pointers() { + if (!mm_fast_mode1()) { + (*m_aux_mm_iterator_shptrs_ptr).clear(); + } + else { + for (int i = 0; i < m_fm1_num_mm_iterators; i += 1) { + m_fm1_key_mm_it_array[i] = assignable_CMMIterators_value_type(); + } + m_fm1_num_mm_iterators = 0; + } + } + mm_const_iterator_type &const_item_pointer(mm_const_iterator_handle_type handle) const { + return (*(handle.m_shptr)); + } + mm_iterator_type &item_pointer(mm_iterator_handle_type handle) { + return (*(handle.m_shptr)); + } + + private: + void release_all_const_item_pointers() { + if (!mm_const_fast_mode1()) { + (*m_aux_mm_const_iterator_shptrs_ptr).clear(); + } + else { + for (int i = 0; i < m_fm1_num_mm_const_iterators; i += 1) { + m_fm1_key_mm_const_it_array[i] = assignable_CMMConstIterators_value_type(); + } + m_fm1_num_mm_const_iterators = 0; + } + } + + mm_iterator_set_type& operator=(const mm_iterator_set_type& src_cref) { + /* This is a special type of class. The state (i.e. member values) of an object of this class is specific to (and only + valid for) the particular instance of the object (or the object of which it is a member). So the correct state of a new + copy of this type of object is not a copy of the state, but rather the state of a new object (which is just the default + initialization state). */ + (*this).reset(); + return (*this); + } + mm_iterator_set_type& operator=(mm_iterator_set_type&& src) { /* see above */ (*this).reset(); return (*this); } + mm_iterator_set_type(const mm_iterator_set_type& src) { /* see above */ } + mm_iterator_set_type(const mm_iterator_set_type&& src) { /* see above */ } + + CHashKey1 m_next_available_key = 0; + + static const int sc_fm1_max_mm_iterators = 6/*arbitrary*/; + + bool mm_const_fast_mode1() const { return (nullptr == m_aux_mm_const_iterator_shptrs_ptr); } + int m_fm1_num_mm_const_iterators = 0; + assignable_CMMConstIterators_value_type m_fm1_key_mm_const_it_array[sc_fm1_max_mm_iterators]; + CMMConstIterators* m_aux_mm_const_iterator_shptrs_ptr = nullptr; + + bool mm_fast_mode1() const { return (nullptr == m_aux_mm_iterator_shptrs_ptr); } + int m_fm1_num_mm_iterators = 0; + assignable_CMMIterators_value_type m_fm1_key_mm_it_array[sc_fm1_max_mm_iterators]; + CMMIterators* m_aux_mm_iterator_shptrs_ptr = nullptr; + + _Myt* m_owner_ptr = nullptr; + + friend class /*_Myt*/msevector<_Ty, _A>; + }; + mutable mm_iterator_set_type m_mmitset; + + public: + mm_const_iterator_type &const_item_pointer(mm_const_iterator_handle_type handle) const { + return m_mmitset.const_item_pointer(handle); + } + mm_iterator_type &item_pointer(mm_iterator_handle_type handle) { + return m_mmitset.item_pointer(handle); + } + + private: + mm_const_iterator_handle_type allocate_new_const_item_pointer() const { return m_mmitset.allocate_new_const_item_pointer(); } + void release_const_item_pointer(mm_const_iterator_handle_type handle) const { m_mmitset.release_const_item_pointer(handle); } + void release_all_const_item_pointers() const { m_mmitset.release_all_const_item_pointers(); } + mm_iterator_handle_type allocate_new_item_pointer() const { return m_mmitset.allocate_new_item_pointer(); } + void release_item_pointer(mm_iterator_handle_type handle) const { m_mmitset.release_item_pointer(handle); } + void release_all_item_pointers() const { m_mmitset.release_all_item_pointers(); } + + public: + class cipointer : public random_access_const_iterator_base { + public: + typedef typename mm_const_iterator_type::iterator_category iterator_category; + typedef typename mm_const_iterator_type::value_type value_type; + typedef typename mm_const_iterator_type::difference_type difference_type; + typedef difference_type distance_type; // retained + typedef typename mm_const_iterator_type::pointer pointer; + typedef typename mm_const_iterator_type::const_pointer const_pointer; + typedef typename mm_const_iterator_type::reference reference; + typedef typename mm_const_iterator_type::const_reference const_reference; + + cipointer(const _Myt& owner_cref) : m_owner_cptr(&owner_cref) { + mm_const_iterator_handle_type handle = m_owner_cptr->allocate_new_const_item_pointer(); + m_handle_shptr = std::make_shared<mm_const_iterator_handle_type>(handle); + } + cipointer(const cipointer& src_cref) : m_owner_cptr(src_cref.m_owner_cptr) { + mm_const_iterator_handle_type handle = m_owner_cptr->allocate_new_const_item_pointer(); + m_handle_shptr = std::make_shared<mm_const_iterator_handle_type>(handle); + const_item_pointer() = src_cref.const_item_pointer(); + } + ~cipointer() { + m_owner_cptr->release_const_item_pointer(*m_handle_shptr); + } + mm_const_iterator_type& const_item_pointer() const { return m_owner_cptr->const_item_pointer(*m_handle_shptr); } + mm_const_iterator_type& cip() const { return const_item_pointer(); } + //const mm_const_iterator_handle_type& handle() const { return (*m_handle_shptr); } + + void reset() { const_item_pointer().reset(); } + bool points_to_an_item() const { return const_item_pointer().points_to_an_item(); } + bool points_to_end_marker() const { return const_item_pointer().points_to_end_marker(); } + bool points_to_beginning() const { return const_item_pointer().points_to_beginning(); } + /* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */ + bool has_next_item_or_end_marker() const { return const_item_pointer().has_next_item_or_end_marker(); } + /* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */ + bool has_next() const { return const_item_pointer().has_next(); } + bool has_previous() const { return const_item_pointer().has_previous(); } + void set_to_beginning() { const_item_pointer().set_to_beginning(); } + void set_to_end_marker() { const_item_pointer().set_to_end_marker(); } + void set_to_next() { const_item_pointer().set_to_next(); } + void set_to_previous() { const_item_pointer().set_to_previous(); } + cipointer& operator ++() { const_item_pointer().operator ++(); return (*this); } + cipointer operator++(int) { cipointer _Tmp = *this; ++*this; return (_Tmp); } + cipointer& operator --() { const_item_pointer().operator --(); return (*this); } + cipointer operator--(int) { cipointer _Tmp = *this; --*this; return (_Tmp); } + void advance(difference_type n) { const_item_pointer().advance(n); } + void regress(difference_type n) { const_item_pointer().regress(n); } + cipointer& operator +=(difference_type n) { const_item_pointer().operator +=(n); return (*this); } + cipointer& operator -=(difference_type n) { const_item_pointer().operator -=(n); return (*this); } + cipointer operator+(difference_type n) const { auto retval = (*this); retval += n; return retval; } + cipointer operator-(difference_type n) const { return ((*this) + (-n)); } + difference_type operator-(const cipointer& _Right_cref) const { return const_item_pointer() - (_Right_cref.const_item_pointer()); } + const_reference operator*() const { return const_item_pointer().operator*(); } + const_reference item() const { return operator*(); } + const_reference previous_item() const { return const_item_pointer().previous_item(); } + const_pointer operator->() const { return const_item_pointer().operator->(); } + const_reference operator[](difference_type _Off) const { return const_item_pointer()[_Off]; } + cipointer& operator=(const cipointer& _Right_cref) { const_item_pointer().operator=(_Right_cref.const_item_pointer()); return (*this); } + bool operator==(const cipointer& _Right_cref) const { return const_item_pointer().operator==(_Right_cref.const_item_pointer()); } + bool operator!=(const cipointer& _Right_cref) const { return (!(_Right_cref == (*this))); } + bool operator<(const cipointer& _Right) const { return (const_item_pointer() < _Right.const_item_pointer()); } + bool operator<=(const cipointer& _Right) const { return (const_item_pointer() <= _Right.const_item_pointer()); } + bool operator>(const cipointer& _Right) const { return (const_item_pointer() > _Right.const_item_pointer()); } + bool operator>=(const cipointer& _Right) const { return (const_item_pointer() >= _Right.const_item_pointer()); } + void set_to_const_item_pointer(const cipointer& _Right_cref) { const_item_pointer().set_to_const_item_pointer(_Right_cref.const_item_pointer()); } + msev_size_t position() const { return const_item_pointer().position(); } + private: + const _Myt* m_owner_cptr = nullptr; + std::shared_ptr<mm_const_iterator_handle_type> m_handle_shptr; + friend class /*_Myt*/msevector<_Ty, _A>; + }; + class ipointer : public random_access_iterator_base { + public: + typedef typename mm_iterator_type::iterator_category iterator_category; + typedef typename mm_iterator_type::value_type value_type; + typedef typename mm_iterator_type::difference_type difference_type; + typedef difference_type distance_type; // retained + typedef typename mm_iterator_type::pointer pointer; + typedef typename mm_iterator_type::reference reference; + + ipointer(_Myt& owner_ref) : m_owner_ptr(&owner_ref) { + mm_iterator_handle_type handle = m_owner_ptr->allocate_new_item_pointer(); + m_handle_shptr = std::make_shared<mm_iterator_handle_type>(handle); + } + ipointer(const ipointer& src_cref) : m_owner_ptr(src_cref.m_owner_ptr) { + mm_iterator_handle_type handle = m_owner_ptr->allocate_new_item_pointer(); + m_handle_shptr = std::make_shared<mm_iterator_handle_type>(handle); + item_pointer() = src_cref.item_pointer(); + } + ~ipointer() { + m_owner_ptr->release_item_pointer(*m_handle_shptr); + } + mm_iterator_type& item_pointer() const { return m_owner_ptr->item_pointer(*m_handle_shptr); } + mm_iterator_type& ip() const { return item_pointer(); } + //const mm_iterator_handle_type& handle() const { return (*m_handle_shptr); } + operator cipointer() const { + cipointer retval(*m_owner_ptr); + retval.const_item_pointer().set_to_beginning(); + retval.const_item_pointer().advance(msev_int(item_pointer().position())); + return retval; + } + + void reset() { item_pointer().reset(); } + bool points_to_an_item() const { return item_pointer().points_to_an_item(); } + bool points_to_end_marker() const { return item_pointer().points_to_end_marker(); } + bool points_to_beginning() const { return item_pointer().points_to_beginning(); } + /* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */ + bool has_next_item_or_end_marker() const { return item_pointer().has_next_item_or_end_marker(); } + /* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */ + bool has_next() const { return item_pointer().has_next(); } + bool has_previous() const { return item_pointer().has_previous(); } + void set_to_beginning() { item_pointer().set_to_beginning(); } + void set_to_end_marker() { item_pointer().set_to_end_marker(); } + void set_to_next() { item_pointer().set_to_next(); } + void set_to_previous() { item_pointer().set_to_previous(); } + ipointer& operator ++() { item_pointer().operator ++(); return (*this); } + ipointer operator++(int) { ipointer _Tmp = *this; ++*this; return (_Tmp); } + ipointer& operator --() { item_pointer().operator --(); return (*this); } + ipointer operator--(int) { ipointer _Tmp = *this; --*this; return (_Tmp); } + void advance(difference_type n) { item_pointer().advance(n); } + void regress(difference_type n) { item_pointer().regress(n); } + ipointer& operator +=(difference_type n) { item_pointer().operator +=(n); return (*this); } + ipointer& operator -=(difference_type n) { item_pointer().operator -=(n); return (*this); } + ipointer operator+(difference_type n) const { auto retval = (*this); retval += n; return retval; } + ipointer operator-(difference_type n) const { return ((*this) + (-n)); } + difference_type operator-(const ipointer& _Right_cref) const { return item_pointer() - (_Right_cref.item_pointer()); } + reference operator*() const { return item_pointer().operator*(); } + reference item() const { return operator*(); } + reference previous_item() const { return item_pointer().previous_item(); } + pointer operator->() const { return item_pointer().operator->(); } + reference operator[](difference_type _Off) const { return item_pointer()[_Off]; } + ipointer& operator=(const ipointer& _Right_cref) { item_pointer().operator=(_Right_cref.item_pointer()); return (*this); } + bool operator==(const ipointer& _Right_cref) const { return item_pointer().operator==(_Right_cref.item_pointer()); } + bool operator!=(const ipointer& _Right_cref) const { return (!(_Right_cref == (*this))); } + bool operator<(const ipointer& _Right) const { return (item_pointer() < _Right.item_pointer()); } + bool operator<=(const ipointer& _Right) const { return (item_pointer() <= _Right.item_pointer()); } + bool operator>(const ipointer& _Right) const { return (item_pointer() > _Right.item_pointer()); } + bool operator>=(const ipointer& _Right) const { return (item_pointer() >= _Right.item_pointer()); } + void set_to_item_pointer(const ipointer& _Right_cref) { item_pointer().set_to_item_pointer(_Right_cref.item_pointer()); } + msev_size_t position() const { return item_pointer().position(); } + private: + _Myt* m_owner_ptr = nullptr; + std::shared_ptr<mm_iterator_handle_type> m_handle_shptr; + friend class /*_Myt*/msevector<_Ty, _A>; + }; + + ipointer ibegin() { // return ipointer for beginning of mutable sequence + ipointer retval(*this); + retval.set_to_beginning(); + return retval; + } + cipointer ibegin() const { // return ipointer for beginning of nonmutable sequence + cipointer retval(*this); + retval.set_to_beginning(); + return retval; + } + ipointer iend() { // return ipointer for end of mutable sequence + ipointer retval(*this); + retval.set_to_end_marker(); + return retval; + } + cipointer iend() const { // return ipointer for end of nonmutable sequence + cipointer retval(*this); + retval.set_to_end_marker(); + return retval; + } + cipointer cibegin() const { // return ipointer for beginning of nonmutable sequence + cipointer retval(*this); + retval.set_to_beginning(); + return retval; + } + cipointer ciend() const { // return ipointer for end of nonmutable sequence + cipointer retval(*this); + retval.set_to_end_marker(); + return retval; + } + + msevector(const cipointer &start, const cipointer &end, const _A& _Al = _A()) + : base_class(_Al), m_mmitset(*this) { + /*m_debug_size = size();*/ + assign(start, end); + } + void assign(const mm_const_iterator_type &start, const mm_const_iterator_type &end) { + 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")); } + 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")); } + typename base_class::const_iterator _F = start; + typename base_class::const_iterator _L = end; + (*this).assign(_F, _L); + } + void assign_inclusive(const mm_const_iterator_type &first, const mm_const_iterator_type &last) { + auto end = last; + end++; // this should include some checks + (*this).assign(first, end); + } + void assign(const cipointer &start, const cipointer &end) { + assign(start.const_item_pointer(), end.const_item_pointer()); + } + void assign_inclusive(const cipointer &first, const cipointer &last) { + assign_inclusive(first.const_item_pointer(), last.const_item_pointer()); + } + void insert_before(const mm_const_iterator_type &pos, size_type _M, const _Ty& _X) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); } + typename base_class::const_iterator _P = pos; + (*this).insert(_P, _M, _X); + } + void insert_before(const mm_const_iterator_type &pos, _Ty&& _X) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); } + typename base_class::const_iterator _P = pos; + (*this).insert(_P, 1, std::move(_X)); + } + void insert_before(const mm_const_iterator_type &pos, const _Ty& _X = _Ty()) { (*this).insert(pos, 1, _X); } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + void insert_before(const mm_const_iterator_type &pos, const _Iter &start, const _Iter &end) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); } + //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")); } + typename base_class::const_iterator _P = pos; + (*this).insert(_P, start, end); + } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + void insert_before_inclusive(const mm_const_iterator_type &pos, const _Iter &first, const _Iter &last) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); } + 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")); } + 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")); } + typename base_class::const_iterator _P = pos; + auto _L = last; + _L++; + (*this).insert(_P, first, _L); + } + void insert_before(const mm_const_iterator_type &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { // insert initializer_list + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); } + typename base_class::const_iterator _P = pos; + (*this).insert(_P, _Ilist); + } + ipointer insert_before(const cipointer &pos, size_type _M, const _Ty& _X) { + msev_size_t original_pos = pos.position(); + insert_before(pos.const_item_pointer(), _M, _X); + ipointer retval(*this); retval.advance(msev_int(original_pos)); + return retval; + } + ipointer insert_before(const cipointer &pos, _Ty&& _X) { + msev_size_t original_pos = pos.position(); + insert_before(pos.const_item_pointer(), std::move(_X)); + ipointer retval(*this); retval.advance(msev_int(original_pos)); + return retval; + } + ipointer insert_before(const cipointer &pos, const _Ty& _X = _Ty()) { return insert_before(pos, 1, _X); } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + ipointer insert_before(const cipointer &pos, const _Iter &start, const _Iter &end) { + msev_size_t original_pos = pos.position(); + insert_before(pos.const_item_pointer(), start, end); + ipointer retval(*this); retval.advance(msev_int(original_pos)); + return retval; + } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + ipointer insert_before_inclusive(const cipointer &pos, const _Iter &first, const _Iter &last) { + auto end = last; end++; + return insert_before(pos, first, end); + } + ipointer insert_before(const cipointer &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { // insert initializer_list + msev_size_t original_pos = pos.position(); + (*this).insert_before(pos.const_item_pointer(), _Ilist); + ipointer retval(*this); retval.advance(msev_int(original_pos)); + return retval; + } + void insert_before(msev_size_t pos, _Ty&& _X) { + typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos); + (*this).insert(_P, std::move(_X)); + } + void insert_before(msev_size_t pos, const _Ty& _X = _Ty()) { + typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos); + (*this).insert(_P, _X); + } + void insert_before(msev_size_t pos, size_t _M, const _Ty& _X) { + typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos); + (*this).insert(_P, _M, _X); + } + void insert_before(msev_size_t pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { // insert initializer_list + typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos); + (*this).insert(_P, _Ilist); + } + /* These insert() functions are just aliases for their corresponding insert_before() functions. */ + ipointer insert(const cipointer &pos, size_type _M, const _Ty& _X) { return insert_before(pos, _M, _X); } + ipointer insert(const cipointer &pos, _Ty&& _X) { return insert_before(pos, std::move(_X)); } + ipointer insert(const cipointer &pos, const _Ty& _X = _Ty()) { return insert_before(pos, _X); } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + ipointer insert(const cipointer &pos, const _Iter &start, const _Iter &end) { return insert_before(pos, start, end); } + ipointer insert(const cipointer &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { return insert_before(pos, _Ilist); } + template<class ..._Valty> +#if !(defined(GPP4P8_COMPATIBLE)) + void emplace(const mm_const_iterator_type &pos, _Valty&& ..._Val) + { // insert by moving _Val at pos +#else /*!(defined(GPP4P8_COMPATIBLE))*/ + void emplace(const mm_iterator_type &pos, _Valty&& ..._Val) + { // insert by moving _Val at pos +#endif /*!(defined(GPP4P8_COMPATIBLE))*/ + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); } + typename base_class::const_iterator _P = pos; + auto retval = base_class::emplace(_P, std::forward<_Valty>(_Val)...); + } + template<class ..._Valty> +#if !(defined(GPP4P8_COMPATIBLE)) + ipointer emplace(const cipointer &pos, _Valty&& ..._Val) + { // insert by moving _Val at pos +#else /*!(defined(GPP4P8_COMPATIBLE))*/ + ipointer emplace(const ipointer &pos, _Valty&& ..._Val) + { // insert by moving _Val at pos +#endif /*!(defined(GPP4P8_COMPATIBLE))*/ + msev_size_t original_pos = pos.position(); + (*this).emplace(pos.const_item_pointer(), std::forward<_Valty>(_Val)...); + ipointer retval(*this); retval.advance(msev_int(original_pos)); + return retval; + } + void erase(const mm_const_iterator_type &pos) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + typename base_class::const_iterator _P = pos; + (*this).erase(_P); + } + void erase(const mm_const_iterator_type &start, const mm_const_iterator_type &end) { + if (start.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + if (end.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + typename base_class::const_iterator _F = start; + typename base_class::const_iterator _L = end; + (*this).erase(_F, _L); + } + void erase_inclusive(const mm_const_iterator_type &first, const mm_const_iterator_type &last) { + if (first.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_inclusive() - msevector")); } + if (last.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_inclusive() - msevector")); } + if (!(last.points_to_item())) { MSE_THROW(msevector_range_error("invalid argument - void erase_inclusive() - msevector")); } + typename base_class::const_iterator _F = first; + typename base_class::const_iterator _L = last; + _L++; + (*this).erase(_F, _L); + } + ipointer erase(const cipointer &pos) { + auto retval_pos = pos; + retval_pos.set_to_next(); + erase(pos.const_item_pointer()); + ipointer retval = (*this).ibegin(); + retval.advance(msev_int(retval_pos.position())); + return retval; + } + ipointer erase(const cipointer &start, const cipointer &end) { + auto retval_pos = end; + retval_pos.set_to_next(); + erase(start.const_item_pointer(), end.const_item_pointer()); + ipointer retval = (*this).ibegin(); + retval.advance(msev_int(retval_pos.position())); + return retval; + } + ipointer erase_inclusive(const cipointer &first, const cipointer &last) { + auto end = last; end.set_to_next(); + return erase(first, end); + } + void erase_previous_item(const mm_const_iterator_type &pos) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); } + if (!(pos.has_previous())) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); } + typename base_class::const_iterator _P = pos; + _P--; + (*this).erase(_P); + } + ipointer erase_previous_item(const cipointer &pos) { + erase_previous_item(pos.const_item_pointer()); + ipointer retval = (*this).ibegin(); + retval.advance(pos.position()); + return retval; + } + + + /* ss_const_iterator_type is a bounds checked iterator. */ + class ss_const_iterator_type : public random_access_const_iterator_base { + public: + typedef typename base_class::const_iterator::iterator_category iterator_category; + typedef typename base_class::const_iterator::value_type value_type; + //typedef typename base_class::const_iterator::difference_type difference_type; + typedef typename _Myt::difference_type difference_type; + typedef difference_type distance_type; // retained + typedef typename base_class::const_iterator::pointer pointer; + typedef typename base_class::const_pointer const_pointer; + typedef typename base_class::const_iterator::reference reference; + typedef typename base_class::const_reference const_reference; + + ss_const_iterator_type() {} + void assert_valid_index() const { + if (m_owner_cptr->size() < m_index) { MSE_THROW(msevector_range_error("invalid index - void assert_valid_index() const - ss_const_iterator_type - msevector")); } + } + void reset() { set_to_end_marker(); } + bool points_to_an_item() const { + if (m_owner_cptr->size() > m_index) { return true; } + else { + if (m_index == m_owner_cptr->size()) { return false; } + else { MSE_THROW(msevector_range_error("attempt to use invalid ss_const_iterator_type - bool points_to_an_item() const - ss_const_iterator_type - msevector")); } + } + } + bool points_to_end_marker() const { + if (false == points_to_an_item()) { + assert(m_index == m_owner_cptr->size()); + return true; + } + else { return false; } + } + bool points_to_beginning() const { + if (0 == m_index) { return true; } + else { return false; } + } + /* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */ + bool has_next_item_or_end_marker() const { return points_to_an_item(); } + /* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */ + bool has_next() const { return has_next_item_or_end_marker(); } + bool has_previous() const { + if (m_owner_cptr->size() < m_index) { + MSE_THROW(msevector_range_error("attempt to use invalid ss_const_iterator_type - bool has_previous() const - ss_const_iterator_type - msevector")); + } + else if (1 <= m_index) { + return true; + } + else { + return false; + } + } + void set_to_beginning() { + m_index = 0; + } + void set_to_end_marker() { + m_index = m_owner_cptr->size(); + } + void set_to_next() { + if (points_to_an_item()) { + m_index += 1; + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_next() - ss_const_iterator_type - msevector")); + } + } + void set_to_previous() { + if (has_previous()) { + m_index -= 1; + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_previous() - ss_const_iterator_type - msevector")); + } + } + ss_const_iterator_type& operator ++() { (*this).set_to_next(); return (*this); } + ss_const_iterator_type operator++(int) { ss_const_iterator_type _Tmp = *this; (*this).set_to_next(); return (_Tmp); } + ss_const_iterator_type& operator --() { (*this).set_to_previous(); return (*this); } + ss_const_iterator_type operator--(int) { ss_const_iterator_type _Tmp = *this; (*this).set_to_previous(); return (_Tmp); } + void advance(difference_type n) { + auto new_index = msev_int(m_index) + n; + if ((0 > new_index) || (m_owner_cptr->size() < msev_size_t(new_index))) { + MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - ss_const_iterator_type - msevector")); + } + else { + m_index = msev_size_t(new_index); + } + } + void regress(difference_type n) { advance(-n); } + ss_const_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); } + ss_const_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); } + ss_const_iterator_type operator+(difference_type n) const { + ss_const_iterator_type retval; retval.m_owner_cptr = m_owner_cptr; + retval = (*this); + retval.advance(n); + return retval; + } + ss_const_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); } + difference_type operator-(const ss_const_iterator_type &rhs) const { + if (rhs.m_owner_cptr != (*this).m_owner_cptr) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const ss_const_iterator_type &rhs) const - msevector::ss_const_iterator_type")); } + auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index); + assert(difference_type((*m_owner_cptr).size()) >= retval); + return retval; + } + const_reference operator*() const { + return (*m_owner_cptr).at(msev_as_a_size_t((*this).m_index)); + } + const_reference item() const { return operator*(); } + const_reference previous_item() const { + return m_owner_cptr->at(msev_as_a_size_t(m_index - 1)); + } + const_pointer operator->() const { + return &((*m_owner_cptr).at(msev_as_a_size_t((*this).m_index))); + } + const_reference operator[](difference_type _Off) const { return (*m_owner_cptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); } + /* + ss_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref) + { + msev_int d = std::distance<typename base_class::iterator>(m_owner_cptr->cbegin(), _Right_cref); + if ((0 <= d) && (m_owner_cptr->size() >= d)) { + if (m_owner_cptr->size() == d) { + assert(m_owner_cptr->cend() == _Right_cref); + } + m_index = msev_size_t(d); + base_class::const_iterator::operator=(_Right_cref); + } + else { + MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - ss_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref) - ss_const_iterator_type - msevector")); + } + return (*this); + } + */ + ss_const_iterator_type& operator=(const ss_const_iterator_type& _Right_cref) { + ((*this).m_owner_cptr) = _Right_cref.m_owner_cptr; + (*this).m_index = _Right_cref.m_index; + return (*this); + } + bool operator==(const ss_const_iterator_type& _Right_cref) const { + if (this->m_owner_cptr != _Right_cref.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid argument - ss_const_iterator_type& operator==(const ss_const_iterator_type& _Right) - ss_const_iterator_type - msevector")); } + return (_Right_cref.m_index == m_index); + } + bool operator!=(const ss_const_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); } + bool operator<(const ss_const_iterator_type& _Right) const { + if (this->m_owner_cptr != _Right.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid argument - ss_const_iterator_type& operator<(const ss_const_iterator_type& _Right) - ss_const_iterator_type - msevector")); } + return (m_index < _Right.m_index); + } + bool operator<=(const ss_const_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); } + bool operator>(const ss_const_iterator_type& _Right) const { return (!((*this) <= _Right)); } + bool operator>=(const ss_const_iterator_type& _Right) const { return (!((*this) < _Right)); } + void set_to_const_item_pointer(const ss_const_iterator_type& _Right_cref) { + (*this) = _Right_cref; + } + void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + (*this).reset(); + } + } + void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + auto new_index = (*this).m_index + shift; + if ((0 > new_index) || (m_owner_cptr->size() < new_index)) { + MSE_THROW(msevector_range_error("void shift_inclusive_range() - ss_const_iterator_type - msevector")); + } + else { + (*this).m_index = msev_size_t(new_index); + (*this).sync_const_iterator_to_index(); + } + } + } + msev_size_t position() const { + return m_index; + } + operator typename base_class::const_iterator() const { + typename base_class::const_iterator retval = (*m_owner_cptr).cbegin(); + retval += msev_as_a_size_t(m_index); + return retval; + } + private: + void sync_const_iterator_to_index() { + assert(m_owner_cptr->size() >= (*this).m_index); + //base_class::const_iterator::operator=(m_owner_cptr->cbegin()); + //base_class::const_iterator::operator+=(msev_as_a_size_t(m_index)); + } + msev_size_t m_index = 0; + msev_pointer<const _Myt> m_owner_cptr = nullptr; + friend class /*_Myt*/msevector<_Ty, _A>; + }; + /* ss_iterator_type is a bounds checked iterator. */ + class ss_iterator_type : public random_access_iterator_base { + public: + typedef typename base_class::iterator::iterator_category iterator_category; + typedef typename base_class::iterator::value_type value_type; + //typedef typename base_class::iterator::difference_type difference_type; + typedef typename _Myt::difference_type difference_type; + typedef difference_type distance_type; // retained + typedef typename base_class::iterator::pointer pointer; + typedef typename base_class::iterator::reference reference; + + ss_iterator_type() {} + void reset() { set_to_end_marker(); } + bool points_to_an_item() const { + if (m_owner_ptr->size() > m_index) { return true; } + else { + if (m_index == m_owner_ptr->size()) { return false; } + else { MSE_THROW(msevector_range_error("attempt to use invalid ss_iterator_type - bool points_to_an_item() const - ss_iterator_type - msevector")); } + } + } + bool points_to_end_marker() const { + if (false == points_to_an_item()) { + assert(m_index == m_owner_ptr->size()); + return true; + } + else { return false; } + } + bool points_to_beginning() const { + if (0 == m_index) { return true; } + else { return false; } + } + /* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */ + bool has_next_item_or_end_marker() const { return points_to_an_item(); } + /* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */ + bool has_next() const { return has_next_item_or_end_marker(); } + bool has_previous() const { + if (m_owner_ptr->size() < m_index) { + MSE_THROW(msevector_range_error("attempt to use invalid ss_iterator_type - bool has_previous() const - ss_iterator_type - msevector")); + } else if (1 <= m_index) { + return true; + } + else { + return false; + } + } + void set_to_beginning() { + m_index = 0; + } + void set_to_end_marker() { + m_index = m_owner_ptr->size(); + } + void set_to_next() { + if (points_to_an_item()) { + m_index += 1; + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_next() - ss_const_iterator_type - msevector")); + } + } + void set_to_previous() { + if (has_previous()) { + m_index -= 1; + } + else { + MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_previous() - ss_iterator_type - msevector")); + } + } + ss_iterator_type& operator ++() { (*this).set_to_next(); return (*this); } + ss_iterator_type operator++(int) { ss_iterator_type _Tmp = *this; (*this).set_to_next(); return (_Tmp); } + ss_iterator_type& operator --() { (*this).set_to_previous(); return (*this); } + ss_iterator_type operator--(int) { ss_iterator_type _Tmp = *this; (*this).set_to_previous(); return (_Tmp); } + void advance(difference_type n) { + auto new_index = msev_int(m_index) + n; + if ((0 > new_index) || (m_owner_ptr->size() < msev_size_t(new_index))) { + MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - ss_iterator_type - msevector")); + } + else { + m_index = msev_size_t(new_index); + } + } + void regress(difference_type n) { advance(-n); } + ss_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); } + ss_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); } + ss_iterator_type operator+(difference_type n) const { + ss_iterator_type retval; retval.m_owner_ptr = m_owner_ptr; + retval = (*this); + retval.advance(n); + return retval; + } + ss_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); } + difference_type operator-(const ss_iterator_type& rhs) const { + if (rhs.m_owner_ptr != (*this).m_owner_ptr) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const ss_iterator_type& rhs) const - msevector::ss_iterator_type")); } + auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index); + assert(int((*m_owner_ptr).size()) >= retval); + return retval; + } + reference operator*() const { + return (*m_owner_ptr).at(msev_as_a_size_t((*this).m_index)); + } + reference item() const { return operator*(); } + reference previous_item() const { + return m_owner_ptr->at(msev_as_a_size_t(m_index - 1)); + } + pointer operator->() const { + return &((*m_owner_ptr).at(msev_as_a_size_t((*this).m_index))); + } + reference operator[](difference_type _Off) const { return (*m_owner_ptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); } + /* + ss_iterator_type& operator=(const typename base_class::iterator& _Right_cref) + { + msev_int d = std::distance<typename base_class::iterator>(m_owner_ptr->begin(), _Right_cref); + if ((0 <= d) && (m_owner_ptr->size() >= d)) { + if (m_owner_ptr->size() == d) { + assert(m_owner_ptr->end() == _Right_cref); + } + m_index = msev_size_t(d); + base_class::iterator::operator=(_Right_cref); + } + else { + MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - ss_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - ss_const_iterator_type - msevector")); + } + return (*this); + } + */ + ss_iterator_type& operator=(const ss_iterator_type& _Right_cref) { + ((*this).m_owner_ptr) = _Right_cref.m_owner_ptr; + (*this).m_index = _Right_cref.m_index; + return (*this); + } + bool operator==(const ss_iterator_type& _Right_cref) const { + if (this->m_owner_ptr != _Right_cref.m_owner_ptr) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type& operator==(const ss_iterator_type& _Right) - ss_iterator_type - msevector")); } + return (_Right_cref.m_index == m_index); + } + bool operator!=(const ss_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); } + bool operator<(const ss_iterator_type& _Right) const { + if (this->m_owner_ptr != _Right.m_owner_ptr) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type& operator<(const ss_iterator_type& _Right) - ss_iterator_type - msevector")); } + return (m_index < _Right.m_index); + } + bool operator<=(const ss_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); } + bool operator>(const ss_iterator_type& _Right) const { return (!((*this) <= _Right)); } + bool operator>=(const ss_iterator_type& _Right) const { return (!((*this) < _Right)); } + void set_to_item_pointer(const ss_iterator_type& _Right_cref) { + (*this) = _Right_cref; + } + void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + (*this).reset(); + } + } + void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) { + if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) { + auto new_index = (*this).m_index + shift; + if ((0 > new_index) || (m_owner_ptr->size() < new_index)) { + MSE_THROW(msevector_range_error("void shift_inclusive_range() - ss_iterator_type - msevector")); + } + else { + (*this).m_index = msev_size_t(new_index); + (*this).sync_iterator_to_index(); + } + } + } + msev_size_t position() const { + return m_index; + } + operator ss_const_iterator_type() const { + ss_const_iterator_type retval; + if (nullptr != m_owner_ptr) { + retval = m_owner_ptr->ss_cbegin(); + retval.advance(msev_int(m_index)); + } + return retval; + } + operator typename base_class::iterator() const { + typename base_class::iterator retval = (*m_owner_ptr).begin(); + retval += msev_as_a_size_t(m_index); + return retval; + } + + private: + void sync_iterator_to_index() { + assert(m_owner_ptr->size() >= (*this).m_index); + //base_class::iterator::operator=(m_owner_ptr->begin()); + //base_class::iterator::operator+=(msev_as_a_size_t(m_index)); + } + msev_size_t m_index = 0; + msev_pointer<_Myt> m_owner_ptr = nullptr; + friend class /*_Myt*/msevector<_Ty, _A>; + }; + typedef std::reverse_iterator<ss_iterator_type> ss_reverse_iterator_type; + typedef std::reverse_iterator<ss_const_iterator_type> ss_const_reverse_iterator_type; + + ss_iterator_type ss_begin() + { // return base_class::iterator for beginning of mutable sequence + ss_iterator_type retval; retval.m_owner_ptr = this; + retval.set_to_beginning(); + return retval; + } + + ss_const_iterator_type ss_begin() const + { // return base_class::iterator for beginning of nonmutable sequence + ss_const_iterator_type retval; retval.m_owner_cptr = this; + retval.set_to_beginning(); + return retval; + } + + ss_iterator_type ss_end() + { // return base_class::iterator for end of mutable sequence + ss_iterator_type retval; retval.m_owner_ptr = this; + retval.set_to_end_marker(); + return retval; + } + + ss_const_iterator_type ss_end() const + { // return base_class::iterator for end of nonmutable sequence + ss_const_iterator_type retval; retval.m_owner_cptr = this; + retval.set_to_end_marker(); + return retval; + } + + ss_const_iterator_type ss_cbegin() const + { // return base_class::iterator for beginning of nonmutable sequence + ss_const_iterator_type retval; retval.m_owner_cptr = this; + retval.set_to_beginning(); + return retval; + } + + ss_const_iterator_type ss_cend() const + { // return base_class::iterator for end of nonmutable sequence + ss_const_iterator_type retval; retval.m_owner_cptr = this; + retval.set_to_end_marker(); + return retval; + } + + ss_const_reverse_iterator_type ss_crbegin() const + { // return base_class::iterator for beginning of reversed nonmutable sequence + return (ss_rbegin()); + } + + ss_const_reverse_iterator_type ss_crend() const + { // return base_class::iterator for end of reversed nonmutable sequence + return (ss_rend()); + } + + ss_reverse_iterator_type ss_rbegin() + { // return base_class::iterator for beginning of reversed mutable sequence + return (reverse_iterator(ss_end())); + } + + ss_const_reverse_iterator_type ss_rbegin() const + { // return base_class::iterator for beginning of reversed nonmutable sequence + return (const_reverse_iterator(ss_end())); + } + + ss_reverse_iterator_type ss_rend() + { // return base_class::iterator for end of reversed mutable sequence + return (reverse_iterator(ss_begin())); + } + + ss_const_reverse_iterator_type ss_rend() const + { // return base_class::iterator for end of reversed nonmutable sequence + return (const_reverse_iterator(ss_begin())); + } + + msevector(const ss_const_iterator_type &start, const ss_const_iterator_type &end, const _A& _Al = _A()) + : base_class(_Al), m_mmitset(*this) { + /*m_debug_size = size();*/ + assign(start, end); + } + void assign(const ss_const_iterator_type &start, const ss_const_iterator_type &end) { + 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")); } + 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")); } + typename base_class::const_iterator _F = start; + typename base_class::const_iterator _L = end; + (*this).assign(_F, _L); + } + void assign_inclusive(const ss_const_iterator_type &first, const ss_const_iterator_type &last) { + auto end = last; + end++; // this should include some checks + (*this).assign(first, end); + } + ss_iterator_type insert_before(const ss_const_iterator_type &pos, size_type _M, const _Ty& _X) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - void insert_before() - msevector")); } + pos.assert_valid_index(); + msev_size_t original_pos = pos.position(); + typename base_class::const_iterator _P = pos; + (*this).insert(_P, _M, _X); + ss_iterator_type retval = ss_begin(); + retval.advance(msev_int(original_pos)); + return retval; + } + ss_iterator_type insert_before(const ss_const_iterator_type &pos, _Ty&& _X) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - void insert_before() - msevector")); } + pos.assert_valid_index(); + msev_size_t original_pos = pos.position(); + typename base_class::const_iterator _P = pos; + (*this).insert(_P, std::move(_X)); + ss_iterator_type retval = ss_begin(); + retval.advance(msev_int(original_pos)); + return retval; + } + ss_iterator_type insert_before(const ss_const_iterator_type &pos, const _Ty& _X = _Ty()) { return (*this).insert(pos, 1, _X); } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + ss_iterator_type insert_before(const ss_const_iterator_type &pos, const _Iter &start, const _Iter &end) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type insert_before() - msevector")); } + //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")); } + pos.assert_valid_index(); + msev_size_t original_pos = pos.position(); + typename base_class::const_iterator _P = pos; + (*this).insert(_P, start, end); + ss_iterator_type retval = ss_begin(); + retval.advance(msev_int(original_pos)); + return retval; + } + ss_iterator_type insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type& start, const ss_const_iterator_type &end) { + 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")); } + end.assert_valid_index(); + 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")); } + typename base_class::const_iterator _S = start; + typename base_class::const_iterator _E = end; + return (*this).insert_before(pos, _S, _E); + } + ss_iterator_type insert_before(const ss_const_iterator_type &pos, const _Ty* start, const _Ty* end) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - ss_iterator_type insert_before() - msevector")); } + //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")); } + if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - ss_iterator_type insert_before() - msevector")); } + pos.assert_valid_index(); + msev_size_t original_pos = pos.position(); + typename base_class::const_iterator _P = pos; + (*this).insert(_P, start, end); + ss_iterator_type retval = ss_begin(); + retval.advance(msev_int(original_pos)); + return retval; + } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + ss_iterator_type insert_before_inclusive(const ss_iterator_type &pos, const _Iter &first, const _Iter &last) { + auto end = last; + end++; // this may include some checks + return (*this).insert_before(pos, first, end); + } + ss_iterator_type insert_before(const ss_const_iterator_type &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { // insert initializer_list + if (pos.m_owner_ptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); } + pos.assert_valid_index(); + msev_size_t original_pos = pos.position(); + typename base_class::const_iterator _P = pos; + (*this).insert(_P, _Ilist); + ss_iterator_type retval = ss_begin(); + retval.advance(msev_int(original_pos)); + return retval; + } + /* These insert() functions are just aliases for their corresponding insert_before() functions. */ + ss_iterator_type insert(const ss_const_iterator_type &pos, size_type _M, const _Ty& _X) { return insert_before(pos, _M, _X); } + ss_iterator_type insert(const ss_const_iterator_type &pos, _Ty&& _X) { return insert_before(pos, std::move(_X)); } + ss_iterator_type insert(const ss_const_iterator_type &pos, const _Ty& _X = _Ty()) { return insert_before(pos, _X); } + template<class _Iter + //>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type + , class = _mse_RequireInputIter<_Iter> > + ss_iterator_type insert(const ss_const_iterator_type &pos, const _Iter &start, const _Iter &end) { return insert_before(pos, start, end); } + ss_iterator_type insert(const ss_const_iterator_type &pos, const _Ty* start, const _Ty* &end) { return insert_before(pos, start, end); } + ss_iterator_type insert(const ss_const_iterator_type &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { return insert_before(pos, _Ilist); } + template<class ..._Valty> +#if !(defined(GPP4P8_COMPATIBLE)) + ss_iterator_type emplace(const ss_const_iterator_type &pos, _Valty&& ..._Val) + { // insert by moving _Val at pos + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); } +#else /*!(defined(GPP4P8_COMPATIBLE))*/ + ipointer emplace(const ipointer &pos, _Valty&& ..._Val) + { // insert by moving _Val at pos + if (pos.m_owner_ptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); } +#endif /*!(defined(GPP4P8_COMPATIBLE))*/ + pos.assert_valid_index(); + msev_size_t original_pos = pos.position(); + typename base_class::const_iterator _P = pos; + (*this).emplace(_P, std::forward<_Valty>(_Val)...); + ss_iterator_type retval = ss_begin(); + retval.advance(msev_int(original_pos)); + return retval; + } + ss_iterator_type erase(const ss_const_iterator_type &pos) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + if (!pos.points_to_an_item()) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + auto pos_index = pos.position(); + + typename base_class::const_iterator _P = pos; + (*this).erase(_P); + + ss_iterator_type retval = (*this).ss_begin(); + retval.advance(typename ss_const_iterator_type::difference_type(pos_index)); + return retval; + } + ss_iterator_type erase(const ss_const_iterator_type &start, const ss_const_iterator_type &end) { + if (start.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + if (end.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + if (start.position() > end.position()) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); } + auto pos_index = start.position(); + + typename base_class::const_iterator _F = start; + typename base_class::const_iterator _L = end; + (*this).erase(_F, _L); + + ss_iterator_type retval = (*this).ss_begin(); + retval.advance(typename ss_const_iterator_type::difference_type(pos_index)); + return retval; + } + ss_iterator_type erase_inclusive(const ss_const_iterator_type &first, const ss_const_iterator_type &last) { + auto end = last; end.set_to_next(); + return erase(first, end); + } + void erase_previous_item(const ss_const_iterator_type &pos) { + if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); } + if (!(pos.has_previous())) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); } + typename base_class::const_iterator _P = pos; + _P--; + (*this).erase(_P); + } + }; + +} + +#undef MSE_THROW + +#endif /*ndef MSEMSEVECTOR_H*/ |