| /* Copyright 2003-2008 Joaquin M Lopez Munoz. |
| * Distributed under 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) |
| * |
| * See http://www.boost.org/libs/multi_index for library home page. |
| */ |
| |
| #ifndef BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP |
| #define BOOST_MULTI_INDEX_DETAIL_INDEX_BASE_HPP |
| |
| #if defined(_MSC_VER)&&(_MSC_VER>=1200) |
| #pragma once |
| #endif |
| |
| #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */ |
| #include <boost/call_traits.hpp> |
| #include <boost/detail/workaround.hpp> |
| #include <boost/mpl/vector.hpp> |
| #include <boost/multi_index/detail/copy_map.hpp> |
| #include <boost/multi_index/detail/node_type.hpp> |
| #include <boost/multi_index_container_fwd.hpp> |
| #include <boost/tuple/tuple.hpp> |
| #include <utility> |
| |
| #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) |
| #include <boost/multi_index/detail/index_loader.hpp> |
| #include <boost/multi_index/detail/index_saver.hpp> |
| #endif |
| |
| namespace boost{ |
| |
| namespace multi_index{ |
| |
| namespace detail{ |
| |
| /* The role of this class is threefold: |
| * - tops the linear hierarchy of indices. |
| * - terminates some cascading backbone function calls (insert_, etc.), |
| * - grants access to the backbone functions of the final |
| * multi_index_container class (for access restriction reasons, these |
| * cannot be called directly from the index classes.) |
| */ |
| |
| template<typename Value,typename IndexSpecifierList,typename Allocator> |
| class index_base |
| { |
| protected: |
| typedef index_node_base<Value,Allocator> node_type; |
| typedef typename multi_index_node_type< |
| Value,IndexSpecifierList,Allocator>::type final_node_type; |
| typedef multi_index_container< |
| Value,IndexSpecifierList,Allocator> final_type; |
| typedef tuples::null_type ctor_args_list; |
| typedef typename |
| boost::detail::allocator::rebind_to< |
| Allocator, |
| typename Allocator::value_type>::type final_allocator_type; |
| typedef mpl::vector0<> index_type_list; |
| typedef mpl::vector0<> iterator_type_list; |
| typedef mpl::vector0<> const_iterator_type_list; |
| typedef copy_map< |
| final_node_type, |
| final_allocator_type> copy_map_type; |
| |
| #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) |
| typedef index_saver< |
| node_type, |
| final_allocator_type> index_saver_type; |
| typedef index_loader< |
| node_type, |
| final_node_type, |
| final_allocator_type> index_loader_type; |
| #endif |
| |
| private: |
| typedef typename call_traits<Value>::param_type value_param_type; |
| |
| protected: |
| explicit index_base(const ctor_args_list&,const Allocator&){} |
| |
| void copy_( |
| const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&) |
| {} |
| |
| node_type* insert_(value_param_type v,node_type* x) |
| { |
| boost::detail::allocator::construct(&x->value(),v); |
| return x; |
| } |
| |
| node_type* insert_(value_param_type v,node_type*,node_type* x) |
| { |
| boost::detail::allocator::construct(&x->value(),v); |
| return x; |
| } |
| |
| void erase_(node_type* x) |
| { |
| boost::detail::allocator::destroy(&x->value()); |
| } |
| |
| void delete_node_(node_type* x) |
| { |
| boost::detail::allocator::destroy(&x->value()); |
| } |
| |
| void clear_(){} |
| |
| void swap_(index_base<Value,IndexSpecifierList,Allocator>&){} |
| |
| bool replace_(value_param_type v,node_type* x) |
| { |
| x->value()=v; |
| return true; |
| } |
| |
| bool modify_(node_type*){return true;} |
| |
| bool modify_rollback_(node_type*){return true;} |
| |
| #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) |
| /* serialization */ |
| |
| template<typename Archive> |
| void save_(Archive&,const unsigned int,const index_saver_type&)const{} |
| |
| template<typename Archive> |
| void load_(Archive&,const unsigned int,const index_loader_type&){} |
| #endif |
| |
| #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING) |
| /* invariant stuff */ |
| |
| bool invariant_()const{return true;} |
| #endif |
| |
| /* access to backbone memfuns of Final class */ |
| |
| final_type& final(){return *static_cast<final_type*>(this);} |
| const final_type& final()const{return *static_cast<const final_type*>(this);} |
| |
| final_node_type* final_header()const{return final().header();} |
| |
| bool final_empty_()const{return final().empty_();} |
| std::size_t final_size_()const{return final().size_();} |
| std::size_t final_max_size_()const{return final().max_size_();} |
| |
| std::pair<final_node_type*,bool> final_insert_(value_param_type x) |
| {return final().insert_(x);} |
| std::pair<final_node_type*,bool> final_insert_( |
| value_param_type x,final_node_type* position) |
| {return final().insert_(x,position);} |
| |
| void final_erase_(final_node_type* x){final().erase_(x);} |
| |
| void final_delete_node_(final_node_type* x){final().delete_node_(x);} |
| void final_delete_all_nodes_(){final().delete_all_nodes_();} |
| void final_clear_(){final().clear_();} |
| |
| void final_swap_(final_type& x){final().swap_(x);} |
| bool final_replace_( |
| value_param_type k,final_node_type* x) |
| {return final().replace_(k,x);} |
| |
| template<typename Modifier> |
| bool final_modify_(Modifier& mod,final_node_type* x) |
| {return final().modify_(mod,x);} |
| |
| template<typename Modifier,typename Rollback> |
| bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x) |
| {return final().modify_(mod,back,x);} |
| |
| #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING) |
| void final_check_invariant_()const{final().check_invariant_();} |
| #endif |
| }; |
| |
| } /* namespace multi_index::detail */ |
| |
| } /* namespace multi_index */ |
| |
| } /* namespace boost */ |
| |
| #endif |