Chris@16: /* Copyright 2003-2013 Joaquin M Lopez Munoz.
Chris@16:  * Distributed under the Boost Software License, Version 1.0.
Chris@16:  * (See accompanying file LICENSE_1_0.txt or copy at
Chris@16:  * http://www.boost.org/LICENSE_1_0.txt)
Chris@16:  *
Chris@16:  * See http://www.boost.org/libs/multi_index for library home page.
Chris@16:  */
Chris@16: 
Chris@16: #ifndef BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
Chris@16: #define BOOST_MULTI_INDEX_DETAIL_SAFE_MODE_HPP
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: #pragma once
Chris@16: #endif
Chris@16: 
Chris@16: /* Safe mode machinery, in the spirit of Cay Hortmann's "Safe STL"
Chris@16:  * (http://www.horstmann.com/safestl.html).
Chris@16:  * In this mode, containers of type Container are derived from
Chris@16:  * safe_container<Container>, and their corresponding iterators
Chris@16:  * are wrapped with safe_iterator. These classes provide
Chris@16:  * an internal record of which iterators are at a given moment associated
Chris@16:  * to a given container, and properly mark the iterators as invalid
Chris@16:  * when the container gets destroyed.
Chris@16:  * Iterators are chained in a single attached list, whose header is
Chris@16:  * kept by the container. More elaborate data structures would yield better
Chris@16:  * performance, but I decided to keep complexity to a minimum since
Chris@16:  * speed is not an issue here.
Chris@16:  * Safe mode iterators automatically check that only proper operations
Chris@16:  * are performed on them: for instance, an invalid iterator cannot be
Chris@16:  * dereferenced. Additionally, a set of utilty macros and functions are
Chris@16:  * provided that serve to implement preconditions and cooperate with
Chris@16:  * the framework within the container.
Chris@16:  * Iterators can also be unchecked, i.e. they do not have info about
Chris@16:  * which container they belong in. This situation arises when the iterator
Chris@16:  * is restored from a serialization archive: only information on the node
Chris@16:  * is available, and it is not possible to determine to which container
Chris@16:  * the iterator is associated to. The only sensible policy is to assume
Chris@16:  * unchecked iterators are valid, though this can certainly generate false
Chris@16:  * positive safe mode checks.
Chris@16:  * This is not a full-fledged safe mode framework, and is only intended
Chris@16:  * for use within the limits of Boost.MultiIndex.
Chris@16:  */
Chris@16: 
Chris@16: /* Assertion macros. These resolve to no-ops if
Chris@16:  * !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE).
Chris@16:  */
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16: #undef BOOST_MULTI_INDEX_SAFE_MODE_ASSERT
Chris@16: #define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) ((void)0)
Chris@16: #else
Chris@16: #if !defined(BOOST_MULTI_INDEX_SAFE_MODE_ASSERT)
Chris@16: #include <boost/assert.hpp>
Chris@16: #define BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(expr,error_code) BOOST_ASSERT(expr)
Chris@16: #endif
Chris@16: #endif
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it)                           \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_valid_iterator(it),                                     \
Chris@16:     safe_mode::invalid_iterator);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(it)                 \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_dereferenceable_iterator(it),                           \
Chris@16:     safe_mode::not_dereferenceable_iterator);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(it)                   \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_incrementable_iterator(it),                             \
Chris@16:     safe_mode::not_incrementable_iterator);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(it)                   \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_decrementable_iterator(it),                             \
Chris@16:     safe_mode::not_decrementable_iterator);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,cont)                            \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_is_owner(it,cont),                                      \
Chris@16:     safe_mode::not_owner);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_SAME_OWNER(it0,it1)                          \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_same_owner(it0,it1),                                    \
Chris@16:     safe_mode::not_same_owner);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_VALID_RANGE(it0,it1)                         \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_valid_range(it0,it1),                                   \
Chris@16:     safe_mode::invalid_range);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(it,it0,it1)                    \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_outside_range(it,it0,it1),                              \
Chris@16:     safe_mode::inside_range);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(it,n)                              \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_in_bounds(it,n),                                        \
Chris@16:     safe_mode::out_of_bounds);
Chris@16: 
Chris@16: #define BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(cont0,cont1)             \
Chris@16:   BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(                                        \
Chris@16:     safe_mode::check_different_container(cont0,cont1),                       \
Chris@16:     safe_mode::same_container);
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16: #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
Chris@16: #include <algorithm>
Chris@16: #include <boost/detail/iterator.hpp>
Chris@16: #include <boost/multi_index/detail/access_specifier.hpp>
Chris@16: #include <boost/multi_index/detail/iter_adaptor.hpp>
Chris@16: #include <boost/multi_index/safe_mode_errors.hpp>
Chris@16: #include <boost/noncopyable.hpp>
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@16: #include <boost/serialization/split_member.hpp>
Chris@101: #include <boost/serialization/version.hpp>
Chris@16: #endif
Chris@16: 
Chris@16: #if defined(BOOST_HAS_THREADS)
Chris@16: #include <boost/detail/lightweight_mutex.hpp>
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost{
Chris@16: 
Chris@16: namespace multi_index{
Chris@16: 
Chris@16: namespace safe_mode{
Chris@16: 
Chris@16: /* Checking routines. Assume the best for unchecked iterators
Chris@16:  * (i.e. they pass the checking when there is not enough info
Chris@16:  * to know.)
Chris@16:  */
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_valid_iterator(const Iterator& it)
Chris@16: {
Chris@16:   return it.valid()||it.unchecked();
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_dereferenceable_iterator(const Iterator& it)
Chris@16: {
Chris@16:   return (it.valid()&&it!=it.owner()->end())||it.unchecked();
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_incrementable_iterator(const Iterator& it)
Chris@16: {
Chris@16:   return (it.valid()&&it!=it.owner()->end())||it.unchecked();
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_decrementable_iterator(const Iterator& it)
Chris@16: {
Chris@16:   return (it.valid()&&it!=it.owner()->begin())||it.unchecked();
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_is_owner(
Chris@16:   const Iterator& it,const typename Iterator::container_type& cont)
Chris@16: {
Chris@16:   return (it.valid()&&it.owner()==&cont)||it.unchecked();
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_same_owner(const Iterator& it0,const Iterator& it1)
Chris@16: {
Chris@16:   return (it0.valid()&&it1.valid()&&it0.owner()==it1.owner())||
Chris@16:          it0.unchecked()||it1.unchecked();
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_valid_range(const Iterator& it0,const Iterator& it1)
Chris@16: {
Chris@16:   if(!check_same_owner(it0,it1))return false;
Chris@16: 
Chris@16:   if(it0.valid()){
Chris@16:     Iterator last=it0.owner()->end();
Chris@16:     if(it1==last)return true;
Chris@16: 
Chris@16:     for(Iterator first=it0;first!=last;++first){
Chris@16:       if(first==it1)return true;
Chris@16:     }
Chris@16:     return false;
Chris@16:   }
Chris@16:   return true;
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline bool check_outside_range(
Chris@16:   const Iterator& it,const Iterator& it0,const Iterator& it1)
Chris@16: {
Chris@16:   if(!check_same_owner(it0,it1))return false;
Chris@16: 
Chris@16:   if(it0.valid()){
Chris@16:     Iterator last=it0.owner()->end();
Chris@16:     bool found=false;
Chris@16: 
Chris@16:     Iterator first=it0;
Chris@16:     for(;first!=last;++first){
Chris@16:       if(first==it1)break;
Chris@16:     
Chris@16:       /* crucial that this check goes after previous break */
Chris@16:     
Chris@16:       if(first==it)found=true;
Chris@16:     }
Chris@16:     if(first!=it1)return false;
Chris@16:     return !found;
Chris@16:   }
Chris@16:   return true;
Chris@16: }
Chris@16: 
Chris@16: template<typename Iterator,typename Difference>
Chris@16: inline bool check_in_bounds(const Iterator& it,Difference n)
Chris@16: {
Chris@16:   if(it.unchecked())return true;
Chris@16:   if(!it.valid())   return false;
Chris@16:   if(n>0)           return it.owner()->end()-it>=n;
Chris@16:   else              return it.owner()->begin()-it<=n;
Chris@16: }
Chris@16: 
Chris@16: template<typename Container>
Chris@16: inline bool check_different_container(
Chris@16:   const Container& cont0,const Container& cont1)
Chris@16: {
Chris@16:   return &cont0!=&cont1;
Chris@16: }
Chris@16: 
Chris@16: /* Invalidates all iterators equivalent to that given. Safe containers
Chris@16:  * must call this when deleting elements: the safe mode framework cannot
Chris@16:  * perform this operation automatically without outside help.
Chris@16:  */
Chris@16: 
Chris@16: template<typename Iterator>
Chris@16: inline void detach_equivalent_iterators(Iterator& it)
Chris@16: {
Chris@16:   if(it.valid()){
Chris@16:     {
Chris@16: #if defined(BOOST_HAS_THREADS)
Chris@16:       boost::detail::lightweight_mutex::scoped_lock lock(it.cont->mutex);
Chris@16: #endif
Chris@16: 
Chris@16:       Iterator *prev_,*next_;
Chris@16:       for(
Chris@16:         prev_=static_cast<Iterator*>(&it.cont->header);
Chris@16:         (next_=static_cast<Iterator*>(prev_->next))!=0;){
Chris@16:         if(next_!=&it&&*next_==it){
Chris@16:           prev_->next=next_->next;
Chris@16:           next_->cont=0;
Chris@16:         }
Chris@16:         else prev_=next_;
Chris@16:       }
Chris@16:     }
Chris@16:     it.detach();
Chris@16:   }
Chris@16: }
Chris@16: 
Chris@16: template<typename Container> class safe_container; /* fwd decl. */
Chris@16: 
Chris@16: } /* namespace multi_index::safe_mode */
Chris@16: 
Chris@16: namespace detail{
Chris@16: 
Chris@16: class safe_container_base;                 /* fwd decl. */
Chris@16: 
Chris@16: class safe_iterator_base
Chris@16: {
Chris@16: public:
Chris@16:   bool valid()const{return cont!=0;}
Chris@16:   bool unchecked()const{return unchecked_;}
Chris@16: 
Chris@16:   inline void detach();
Chris@16: 
Chris@16:   void uncheck()
Chris@16:   {
Chris@16:     detach();
Chris@16:     unchecked_=true;
Chris@16:   }
Chris@16: 
Chris@16: protected:
Chris@16:   safe_iterator_base():cont(0),next(0),unchecked_(false){}
Chris@16: 
Chris@16:   explicit safe_iterator_base(safe_container_base* cont_):
Chris@16:     unchecked_(false)
Chris@16:   {
Chris@16:     attach(cont_);
Chris@16:   }
Chris@16: 
Chris@16:   safe_iterator_base(const safe_iterator_base& it):
Chris@16:     unchecked_(it.unchecked_)
Chris@16:   {
Chris@16:     attach(it.cont);
Chris@16:   }
Chris@16: 
Chris@16:   safe_iterator_base& operator=(const safe_iterator_base& it)
Chris@16:   {
Chris@16:     unchecked_=it.unchecked_;
Chris@16:     safe_container_base* new_cont=it.cont;
Chris@16:     if(cont!=new_cont){
Chris@16:       detach();
Chris@16:       attach(new_cont);
Chris@16:     }
Chris@16:     return *this;
Chris@16:   }
Chris@16: 
Chris@16:   ~safe_iterator_base()
Chris@16:   {
Chris@16:     detach();
Chris@16:   }
Chris@16: 
Chris@16:   const safe_container_base* owner()const{return cont;}
Chris@16: 
Chris@16: BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS:
Chris@16:   friend class safe_container_base;
Chris@16: 
Chris@16: #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
Chris@16:   template<typename>          friend class safe_mode::safe_container;
Chris@16:   template<typename Iterator> friend
Chris@16:     void safe_mode::detach_equivalent_iterators(Iterator&);
Chris@16: #endif
Chris@16: 
Chris@16:   inline void attach(safe_container_base* cont_);
Chris@16: 
Chris@16:   safe_container_base* cont;
Chris@16:   safe_iterator_base*  next;
Chris@16:   bool                 unchecked_;
Chris@16: };
Chris@16: 
Chris@16: class safe_container_base:private noncopyable
Chris@16: {
Chris@16: public:
Chris@16:   safe_container_base(){}
Chris@16: 
Chris@16: BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
Chris@16:   friend class safe_iterator_base;
Chris@16: 
Chris@16: #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
Chris@16:   template<typename Iterator> friend
Chris@16:     void safe_mode::detach_equivalent_iterators(Iterator&);
Chris@16: #endif
Chris@16: 
Chris@16:   ~safe_container_base()
Chris@16:   {
Chris@16:     /* Detaches all remaining iterators, which by now will
Chris@16:      * be those pointing to the end of the container.
Chris@16:      */
Chris@16: 
Chris@16:     for(safe_iterator_base* it=header.next;it;it=it->next)it->cont=0;
Chris@16:     header.next=0;
Chris@16:   }
Chris@16: 
Chris@16:   void swap(safe_container_base& x)
Chris@16:   {
Chris@16:     for(safe_iterator_base* it0=header.next;it0;it0=it0->next)it0->cont=&x;
Chris@16:     for(safe_iterator_base* it1=x.header.next;it1;it1=it1->next)it1->cont=this;
Chris@16:     std::swap(header.cont,x.header.cont);
Chris@16:     std::swap(header.next,x.header.next);
Chris@16:   }
Chris@16: 
Chris@16:   safe_iterator_base header;
Chris@16: 
Chris@16: #if defined(BOOST_HAS_THREADS)
Chris@16:   boost::detail::lightweight_mutex mutex;
Chris@16: #endif
Chris@16: };
Chris@16: 
Chris@16: void safe_iterator_base::attach(safe_container_base* cont_)
Chris@16: {
Chris@16:   cont=cont_;
Chris@16:   if(cont){
Chris@16: #if defined(BOOST_HAS_THREADS)
Chris@16:     boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
Chris@16: #endif
Chris@16: 
Chris@16:     next=cont->header.next;
Chris@16:     cont->header.next=this;
Chris@16:   }
Chris@16: }
Chris@16: 
Chris@16: void safe_iterator_base::detach()
Chris@16: {
Chris@16:   if(cont){
Chris@16: #if defined(BOOST_HAS_THREADS)
Chris@16:     boost::detail::lightweight_mutex::scoped_lock lock(cont->mutex);
Chris@16: #endif
Chris@16: 
Chris@16:     safe_iterator_base *prev_,*next_;
Chris@16:     for(prev_=&cont->header;(next_=prev_->next)!=this;prev_=next_){}
Chris@16:     prev_->next=next;
Chris@16:     cont=0;
Chris@16:   }
Chris@16: }
Chris@16: 
Chris@16: } /* namespace multi_index::detail */
Chris@16: 
Chris@16: namespace safe_mode{
Chris@16: 
Chris@16: /* In order to enable safe mode on a container:
Chris@16:  *   - The container must derive from safe_container<container_type>,
Chris@16:  *   - iterators must be generated via safe_iterator, which adapts a
Chris@16:  *     preexistent unsafe iterator class.
Chris@16:  */
Chris@16:  
Chris@16: template<typename Container>
Chris@16: class safe_container;
Chris@16: 
Chris@16: template<typename Iterator,typename Container>
Chris@16: class safe_iterator:
Chris@16:   public detail::iter_adaptor<safe_iterator<Iterator,Container>,Iterator>,
Chris@16:   public detail::safe_iterator_base
Chris@16: {
Chris@16:   typedef detail::iter_adaptor<safe_iterator,Iterator> super;
Chris@16:   typedef detail::safe_iterator_base                   safe_super;
Chris@16: 
Chris@16: public:
Chris@16:   typedef Container                                    container_type;
Chris@16:   typedef typename Iterator::reference                 reference;
Chris@16:   typedef typename Iterator::difference_type           difference_type;
Chris@16: 
Chris@16:   safe_iterator(){}
Chris@16:   explicit safe_iterator(safe_container<container_type>* cont_):
Chris@16:     safe_super(cont_){}
Chris@16:   template<typename T0>
Chris@16:   safe_iterator(const T0& t0,safe_container<container_type>* cont_):
Chris@16:     super(Iterator(t0)),safe_super(cont_){}
Chris@16:   template<typename T0,typename T1>
Chris@16:   safe_iterator(
Chris@16:     const T0& t0,const T1& t1,safe_container<container_type>* cont_):
Chris@16:     super(Iterator(t0,t1)),safe_super(cont_){}
Chris@16: 
Chris@16:   safe_iterator& operator=(const safe_iterator& x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
Chris@16:     this->base_reference()=x.base_reference();
Chris@16:     safe_super::operator=(x);
Chris@16:     return *this;
Chris@16:   }
Chris@16: 
Chris@16:   const container_type* owner()const
Chris@16:   {
Chris@16:     return
Chris@16:       static_cast<const container_type*>(
Chris@16:         static_cast<const safe_container<container_type>*>(
Chris@16:           this->safe_super::owner()));
Chris@16:   }
Chris@16: 
Chris@16:   /* get_node is not to be used by the user */
Chris@16: 
Chris@16:   typedef typename Iterator::node_type node_type;
Chris@16: 
Chris@16:   node_type* get_node()const{return this->base_reference().get_node();}
Chris@16: 
Chris@16: private:
Chris@16:   friend class boost::multi_index::detail::iter_adaptor_access;
Chris@16: 
Chris@16:   reference dereference()const
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(*this);
Chris@16:     return *(this->base_reference());
Chris@16:   }
Chris@16: 
Chris@16:   bool equal(const safe_iterator& x)const
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
Chris@16:     BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
Chris@16:     return this->base_reference()==x.base_reference();
Chris@16:   }
Chris@16: 
Chris@16:   void increment()
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_INCREMENTABLE_ITERATOR(*this);
Chris@16:     ++(this->base_reference());
Chris@16:   }
Chris@16: 
Chris@16:   void decrement()
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DECREMENTABLE_ITERATOR(*this);
Chris@16:     --(this->base_reference());
Chris@16:   }
Chris@16: 
Chris@16:   void advance(difference_type n)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IN_BOUNDS(*this,n);
Chris@16:     this->base_reference()+=n;
Chris@16:   }
Chris@16: 
Chris@16:   difference_type distance_to(const safe_iterator& x)const
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(x);
Chris@16:     BOOST_MULTI_INDEX_CHECK_SAME_OWNER(*this,x);
Chris@16:     return x.base_reference()-this->base_reference();
Chris@16:   }
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@16:   /* Serialization. Note that Iterator::save and Iterator:load
Chris@16:    * are assumed to be defined and public: at first sight it seems
Chris@16:    * like we could have resorted to the public serialization interface
Chris@16:    * for doing the forwarding to the adapted iterator class:
Chris@16:    *   ar<<base_reference();
Chris@16:    *   ar>>base_reference();
Chris@16:    * but this would cause incompatibilities if a saving
Chris@16:    * program is in safe mode and the loading program is not, or
Chris@16:    * viceversa --in safe mode, the archived iterator data is one layer
Chris@16:    * deeper, this is especially relevant with XML archives.
Chris@16:    * It'd be nice if Boost.Serialization provided some forwarding
Chris@16:    * facility for use by adaptor classes.
Chris@16:    */ 
Chris@16: 
Chris@16:   friend class boost::serialization::access;
Chris@16: 
Chris@16:   BOOST_SERIALIZATION_SPLIT_MEMBER()
Chris@16: 
Chris@16:   template<class Archive>
Chris@16:   void save(Archive& ar,const unsigned int version)const
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(*this);
Chris@16:     this->base_reference().save(ar,version);
Chris@16:   }
Chris@16: 
Chris@16:   template<class Archive>
Chris@16:   void load(Archive& ar,const unsigned int version)
Chris@16:   {
Chris@16:     this->base_reference().load(ar,version);
Chris@16:     safe_super::uncheck();
Chris@16:   }
Chris@16: #endif
Chris@16: };
Chris@16: 
Chris@16: template<typename Container>
Chris@16: class safe_container:public detail::safe_container_base
Chris@16: {
Chris@16:   typedef detail::safe_container_base super;
Chris@16: 
Chris@16: public:
Chris@16:   void detach_dereferenceable_iterators()
Chris@16:   {
Chris@16:     typedef typename Container::iterator iterator;
Chris@16: 
Chris@16:     iterator end_=static_cast<Container*>(this)->end();
Chris@16:     iterator *prev_,*next_;
Chris@16:     for(
Chris@16:       prev_=static_cast<iterator*>(&this->header);
Chris@16:       (next_=static_cast<iterator*>(prev_->next))!=0;){
Chris@16:       if(*next_!=end_){
Chris@16:         prev_->next=next_->next;
Chris@16:         next_->cont=0;
Chris@16:       }
Chris@16:       else prev_=next_;
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16:   void swap(safe_container<Container>& x)
Chris@16:   {
Chris@16:     super::swap(x);
Chris@16:   }
Chris@16: };
Chris@16: 
Chris@16: } /* namespace multi_index::safe_mode */
Chris@16: 
Chris@16: } /* namespace multi_index */
Chris@16: 
Chris@101: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@101: namespace serialization{
Chris@101: template<typename Iterator,typename Container>
Chris@101: struct version<
Chris@101:   boost::multi_index::safe_mode::safe_iterator<Iterator,Container>
Chris@101: >
Chris@101: {
Chris@101:   BOOST_STATIC_CONSTANT(
Chris@101:     int,value=boost::serialization::version<Iterator>::value);
Chris@101: };
Chris@101: } /* namespace serialization */
Chris@101: #endif
Chris@101: 
Chris@16: } /* namespace boost */
Chris@16: 
Chris@16: #endif /* BOOST_MULTI_INDEX_ENABLE_SAFE_MODE */
Chris@16: 
Chris@16: #endif