Line data    Source code

       1             : /* Copyright 2003-2021 Joaquin M Lopez Munoz.
       2             :  * Distributed under the Boost Software License, Version 1.0.
       3             :  * (See accompanying file LICENSE_1_0.txt or copy at
       4             :  * http://www.boost.org/LICENSE_1_0.txt)
       5             :  *
       6             :  * See http://www.boost.org/libs/multi_index for library home page.
       7             :  */
       8             : 
       9             : #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
      10             : #define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP
      11             : 
      12             : #if defined(_MSC_VER)
      13             : #pragma once
      14             : #endif
      15             : 
      16             : #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
      17             : #include <boost/core/addressof.hpp>
      18             : #include <boost/core/no_exceptions_support.hpp>
      19             : #include <boost/detail/workaround.hpp>
      20             : #include <boost/move/utility_core.hpp>
      21             : #include <boost/mpl/vector.hpp>
      22             : #include <boost/multi_index/detail/allocator_traits.hpp>
      23             : #include <boost/multi_index/detail/copy_map.hpp>
      24             : #include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
      25             : #include <boost/multi_index/detail/index_access_sequence.hpp>
      26             : #include <boost/multi_index/detail/node_handle.hpp>
      27             : #include <boost/multi_index/detail/node_type.hpp>
      28             : #include <boost/multi_index/detail/vartempl_support.hpp>
      29             : #include <boost/multi_index_container_fwd.hpp>
      30             : #include <boost/tuple/tuple.hpp>
      31             : #include <utility>
      32             : 
      33             : #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
      34             : #include <boost/multi_index/detail/index_loader.hpp>
      35             : #include <boost/multi_index/detail/index_saver.hpp>
      36             : #endif
      37             : 
      38             : namespace boost{
      39             : 
      40             : namespace multi_index{
      41             : 
      42             : namespace detail{
      43             : 
      44             : /* The role of this class is threefold:
      45             :  *   - tops the linear hierarchy of indices.
      46             :  *   - terminates some cascading backbone function calls (insert_, etc.),
      47             :  *   - grants access to the backbone functions of the final
      48             :  *     multi_index_container class (for access restriction reasons, these
      49             :  *     cannot be called directly from the index classes.)
      50             :  */
      51             : 
      52             : struct lvalue_tag{};
      53             : struct rvalue_tag{};
      54             : struct emplaced_tag{};
      55             : 
      56             : template<typename Value,typename IndexSpecifierList,typename Allocator>
      57             : class index_base
      58             : {
      59             : protected:
      60             :   typedef index_node_base<Value,Allocator>    index_node_type;
      61             :   typedef typename multi_index_node_type<
      62             :     Value,IndexSpecifierList,Allocator>::type final_node_type;
      63             :   typedef multi_index_container<
      64             :     Value,IndexSpecifierList,Allocator>       final_type;
      65             :   typedef tuples::null_type                   ctor_args_list;
      66             :   typedef typename rebind_alloc_for<
      67             :     Allocator,typename Allocator::value_type
      68             :   >::type                                     final_allocator_type;
      69             :   typedef node_handle<
      70             :     final_node_type,final_allocator_type>     final_node_handle_type;
      71             :   typedef mpl::vector0<>                      index_type_list;
      72             :   typedef mpl::vector0<>                      iterator_type_list;
      73             :   typedef mpl::vector0<>                      const_iterator_type_list;
      74             :   typedef copy_map<
      75             :     final_node_type,
      76             :     final_allocator_type>                     copy_map_type;
      77             : 
      78             : #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
      79             :   typedef index_saver<
      80             :     index_node_type,
      81             :     final_allocator_type>                     index_saver_type;
      82             :   typedef index_loader<
      83             :     index_node_type,
      84             :     final_node_type,
      85             :     final_allocator_type>                     index_loader_type;
      86             : #endif
      87             : 
      88             : private:
      89             :   typedef Value                               value_type;
      90             :   typedef allocator_traits<Allocator>         alloc_traits;
      91             :   typedef typename alloc_traits::size_type    size_type;
      92             : 
      93             : protected:
      94       72607 :   explicit index_base(const ctor_args_list&,const Allocator&){}
      95             : 
      96             :   index_base(
      97             :     const index_base<Value,IndexSpecifierList,Allocator>&,
      98             :     do_not_copy_elements_tag)
      99             :   {}
     100             : 
     101             :   void copy_(
     102             :     const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
     103             :   {}
     104             : 
     105        1549 :   final_node_type* insert_(const value_type& v,final_node_type*& x,lvalue_tag)
     106             :   {
     107        1549 :     x=final().allocate_node();
     108             :     BOOST_TRY{
     109        1549 :       final().construct_value(x,v);
     110        1549 :     }
     111             :     BOOST_CATCH(...){
     112           0 :       final().deallocate_node(x);
     113           0 :       BOOST_RETHROW;
     114           0 :     }
     115             :     BOOST_CATCH_END
     116        1549 :     return x;
     117           0 :   }
     118             : 
     119             :   final_node_type* insert_(const value_type& v,final_node_type*& x,rvalue_tag)
     120             :   {
     121             :     x=final().allocate_node();
     122             :     BOOST_TRY{
     123             :       final().construct_value(x,boost::move(const_cast<value_type&>(v)));
     124             :     }
     125             :     BOOST_CATCH(...){
     126             :       final().deallocate_node(x);
     127             :       BOOST_RETHROW;
     128             :     }
     129             :     BOOST_CATCH_END
     130             :     return x;
     131             :   }
     132             : 
     133       26904 :   final_node_type* insert_(const value_type&,final_node_type*& x,emplaced_tag)
     134             :   {
     135       26904 :     return x;
     136             :   }
     137             : 
     138             :   template<typename MultiIndexContainer>
     139             :   final_node_type* insert_(
     140             :     const value_type&,final_node_type*& x,MultiIndexContainer* p)
     141             :   {
     142             :     p->final_extract_for_transfer_(
     143             :       x,index_access_sequence<final_type>(&final()));
     144             :     return x;
     145             :   }
     146             : 
     147             :   final_node_type* insert_(
     148             :     const value_type& v,index_node_type*,final_node_type*& x,lvalue_tag)
     149             :   {
     150             :     return insert_(v,x,lvalue_tag());
     151             :   }
     152             : 
     153             :   final_node_type* insert_(
     154             :     const value_type& v,index_node_type*,final_node_type*& x,rvalue_tag)
     155             :   {
     156             :     return insert_(v,x,rvalue_tag());
     157             :   }
     158             : 
     159             :   final_node_type* insert_(
     160             :     const value_type&,index_node_type*,final_node_type*& x,emplaced_tag)
     161             :   {
     162             :     return x;
     163             :   }
     164             : 
     165             :   template<typename Dst>
     166       25860 :   void extract_(index_node_type*,Dst){}
     167             : 
     168       23808 :   void clear_(){}
     169             : 
     170             :   template<typename BoolConstant>
     171             :   void swap_(
     172             :     index_base<Value,IndexSpecifierList,Allocator>&,
     173             :     BoolConstant /* swap_allocators */)
     174             :   {}
     175             : 
     176             :   void swap_elements_(index_base<Value,IndexSpecifierList,Allocator>&){}
     177             : 
     178             :   bool replace_(const value_type& v,index_node_type* x,lvalue_tag)
     179             :   {
     180             :     x->value()=v;
     181             :     return true;
     182             :   }
     183             : 
     184             :   bool replace_(const value_type& v,index_node_type* x,rvalue_tag)
     185             :   {
     186             :     x->value()=boost::move(const_cast<value_type&>(v));
     187             :     return true;
     188             :   }
     189             : 
     190     1767476 :   bool modify_(index_node_type*){return true;}
     191             : 
     192             :   bool modify_rollback_(index_node_type*){return true;}
     193             : 
     194             :   bool check_rollback_(index_node_type*)const{return true;}
     195             : 
     196             : #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
     197             :   /* serialization */
     198             : 
     199             :   template<typename Archive>
     200             :   void save_(Archive&,const unsigned int,const index_saver_type&)const{}
     201             : 
     202             :   template<typename Archive>
     203             :   void load_(Archive&,const unsigned int,const index_loader_type&){}
     204             : #endif
     205             : 
     206             : #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
     207             :   /* invariant stuff */
     208             : 
     209             :   bool invariant_()const{return true;}
     210             : #endif
     211             : 
     212             :   /* access to backbone memfuns of Final class */
     213             : 
     214     1851288 :   final_type&       final(){return *static_cast<final_type*>(this);}
     215    35287659 :   const final_type& final()const{return *static_cast<const final_type*>(this);}
     216             : 
     217             :   template<typename Index>
     218             :   static typename Index::final_type& final(Index& x) /* cross-index access */
     219             :     {return static_cast<typename Index::final_type&>(x);}
     220             : 
     221    20061546 :   final_node_type* final_header()const{return final().header();}
     222             : 
     223       73527 :   bool      final_empty_()const{return final().empty_();}
     224    15152541 :   size_type final_size_()const{return final().size_();}
     225             :   size_type final_max_size_()const{return final().max_size_();}
     226             : 
     227        1549 :   std::pair<final_node_type*,bool> final_insert_(const value_type& x)
     228        1549 :     {return final().insert_(x);}
     229             :   std::pair<final_node_type*,bool> final_insert_rv_(const value_type& x)
     230             :     {return final().insert_rv_(x);}
     231             :   template<typename T>
     232             :   std::pair<final_node_type*,bool> final_insert_ref_(const T& t)
     233             :     {return final().insert_ref_(t);}
     234             :   template<typename T>
     235             :   std::pair<final_node_type*,bool> final_insert_ref_(T& t)
     236             :     {return final().insert_ref_(t);}
     237             :   std::pair<final_node_type*,bool> final_insert_nh_(final_node_handle_type& nh)
     238             :     {return final().insert_nh_(nh);}
     239             : 
     240             :   template<typename Index>
     241             :   std::pair<final_node_type*,bool> final_transfer_(Index& x,final_node_type* n)
     242             :     {return final().transfer_(x,n);}
     243             : 
     244             :   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
     245       26904 :   std::pair<final_node_type*,bool> final_emplace_(
     246             :     BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
     247             :   {
     248       26904 :     return final().emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
     249             :   }
     250             : 
     251             :   std::pair<final_node_type*,bool> final_insert_(
     252             :     const value_type& x,final_node_type* position)
     253             :     {return final().insert_(x,position);}
     254             :   std::pair<final_node_type*,bool> final_insert_rv_(
     255             :     const value_type& x,final_node_type* position)
     256             :     {return final().insert_rv_(x,position);}
     257             :   template<typename T>
     258             :   std::pair<final_node_type*,bool> final_insert_ref_(
     259             :     const T& t,final_node_type* position)
     260             :     {return final().insert_ref_(t,position);}
     261             :   template<typename T>
     262             :   std::pair<final_node_type*,bool> final_insert_ref_(
     263             :     T& t,final_node_type* position)
     264             :     {return final().insert_ref_(t,position);}
     265             :   std::pair<final_node_type*,bool> final_insert_nh_(
     266             :     final_node_handle_type& nh,final_node_type* position)
     267             :     {return final().insert_nh_(nh,position);}
     268             : 
     269             :   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
     270             :   std::pair<final_node_type*,bool> final_emplace_hint_(
     271             :     final_node_type* position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
     272             :   {
     273             :     return final().emplace_hint_(
     274             :       position,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
     275             :   }
     276             : 
     277             :   final_node_handle_type final_extract_(final_node_type* x)
     278             :   {
     279             :     return final().extract_(x);
     280             :   } 
     281             : 
     282             :   template<typename Dst>
     283             :   void final_extract_for_transfer_(final_node_type* x,Dst dst)
     284             :   {
     285             :     final().extract_for_transfer_(x,dst);
     286             :   } 
     287             : 
     288       25860 :   void final_erase_(final_node_type* x){final().erase_(x);}
     289             : 
     290        2593 :   void final_delete_node_(final_node_type* x){final().delete_node_(x);}
     291             :   void final_delete_all_nodes_(){final().delete_all_nodes_();}
     292       23808 :   void final_clear_(){final().clear_();}
     293             : 
     294             :   template<typename Index>
     295             :   void final_transfer_range_(
     296             :     Index& x,
     297             :     BOOST_DEDUCED_TYPENAME Index::iterator first,
     298             :     BOOST_DEDUCED_TYPENAME Index::iterator last)
     299             :     {final().transfer_range_(x,first,last);}
     300             : 
     301             :   void final_swap_(final_type& x){final().swap_(x);}
     302             : 
     303             :   bool final_replace_(
     304             :     const value_type& k,final_node_type* x)
     305             :     {return final().replace_(k,x);}
     306             :   bool final_replace_rv_(
     307             :     const value_type& k,final_node_type* x)
     308             :     {return final().replace_rv_(k,x);}
     309             : 
     310             :   template<typename Modifier>
     311     1767476 :   bool final_modify_(Modifier& mod,final_node_type* x)
     312     1767476 :     {return final().modify_(mod,x);}
     313             : 
     314             :   template<typename Modifier,typename Rollback>
     315             :   bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
     316             :     {return final().modify_(mod,back,x);}
     317             : 
     318             : #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
     319             :   void final_check_invariant_()const{final().check_invariant_();}
     320             : #endif
     321             : };
     322             : 
     323             : } /* namespace multi_index::detail */
     324             : 
     325             : } /* namespace multi_index */
     326             : 
     327             : } /* namespace boost */
     328             : 
     329             : #endif