comparison DEPENDENCIES/generic/include/boost/multi_index_container.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 /* Multiply indexed container.
  *
- * Copyright 2003-2013 Joaquin M Lopez Munoz.
+ * Copyright 2003-2014 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_HPP
 #define BOOST_MULTI_INDEX_HPP
 
-#if defined(_MSC_VER)&&(_MSC_VER>=1200)
+#if defined(_MSC_VER)
 #pragma once
 #endif
 
 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
 #include <algorithm>

 #include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
 #include <boost/multi_index/detail/converter.hpp>
 #include <boost/multi_index/detail/header_holder.hpp>
 #include <boost/multi_index/detail/has_tag.hpp>
 #include <boost/multi_index/detail/no_duplicate_tags.hpp>
-#include <boost/multi_index/detail/prevent_eti.hpp>
 #include <boost/multi_index/detail/safe_mode.hpp>
 #include <boost/multi_index/detail/scope_guard.hpp>
 #include <boost/multi_index/detail/vartempl_support.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>

       Allocator,
       typename detail::multi_index_node_type<
         Value,IndexSpecifierList,Allocator>::type
     >::type>,
   BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder<
-    typename detail::prevent_eti<
+    typename boost::detail::allocator::rebind_to<
       Allocator,
-      typename boost::detail::allocator::rebind_to<
-        Allocator,
-        typename detail::multi_index_node_type<
-          Value,IndexSpecifierList,Allocator>::type
-      >::type
+      typename detail::multi_index_node_type<
+        Value,IndexSpecifierList,Allocator>::type
     >::type::pointer,
     multi_index_container<Value,IndexSpecifierList,Allocator> >,
   public detail::multi_index_base_type<
     Value,IndexSpecifierList,Allocator>::type
 {

 
   typedef typename detail::multi_index_base_type<
       Value,IndexSpecifierList,Allocator>::type   super;
   typedef typename
   boost::detail::allocator::rebind_to<
-      Allocator,
-      typename super::node_type
+    Allocator,
+    typename super::node_type
   >::type                                         node_allocator;
   typedef ::boost::base_from_member<
     node_allocator>                               bfm_allocator;
   typedef detail::header_holder<
-    typename detail::prevent_eti<
-      Allocator,
-      node_allocator
-    >::type::pointer,
+    typename node_allocator::pointer,
     multi_index_container>                        bfm_header;
 
-#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
-  /* see definition of index_type_list below */
-  typedef typename super::index_type_list         super_index_type_list;
-#endif
 
 public:
   /* All types are inherited from super, a few are explicitly
    * brought forward here to save us some typename's.
    */
 
-  typedef typename super::ctor_args_list          ctor_args_list;
-  typedef IndexSpecifierList                      index_specifier_type_list;
+  typedef typename super::ctor_args_list           ctor_args_list;
+  typedef IndexSpecifierList                       index_specifier_type_list;
  
-#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
-  /* MSVC++ 6.0 chokes on moderately long index lists (around 6 indices
-   * or more), with errors ranging from corrupt exes to duplicate
-   * comdats. The following type hiding hack alleviates this condition;
-   * best results combined with type hiding of the indexed_by construct
-   * itself, as explained in the "Compiler specifics" section of
-   * the documentation.
-   */
-
-  struct index_type_list:super_index_type_list
-  {
-    typedef index_type_list                      type;
-    typedef typename super_index_type_list::back back;
-    typedef mpl::v_iter<type,0>                  begin;
-    typedef mpl::v_iter<
-      type,
-      mpl::size<super_index_type_list>::value>   end;
-  };
-#else
   typedef typename super::index_type_list          index_type_list;
-#endif
 
   typedef typename super::iterator_type_list       iterator_type_list;
   typedef typename super::const_iterator_type_list const_iterator_type_list;
   typedef typename super::value_type               value_type;
   typedef typename super::final_allocator_type     allocator_type;

     super(args_list,bfm_allocator::member),
     node_count(0)
   {
     BOOST_MULTI_INDEX_CHECK_INVARIANT;
     BOOST_TRY{
-      typedef typename std::initializer_list<Value>::iterator init_iterator;
+      typedef const Value* init_iterator;
 
       iterator hint=super::end();
       for(init_iterator first=list.begin(),last=list.end();
           first!=last;++first){
         hint=super::make_iterator(insert_(*first,hint.get_node()).first);

 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
   multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
     std::initializer_list<Value> list)
   {
     BOOST_MULTI_INDEX_CHECK_INVARIANT;
-    typedef typename std::initializer_list<Value>::iterator init_iterator;
+    typedef const Value* init_iterator;
 
     multi_index_container x(*this,detail::do_not_copy_elements_tag());    
     iterator hint=x.end();
     for(init_iterator first=list.begin(),last=list.end();
         first!=last;++first){

     x.swap_elements_(*this);
     return*this;
   }
 #endif
 
-  allocator_type get_allocator()const
+  allocator_type get_allocator()const BOOST_NOEXCEPT
   {
     return allocator_type(bfm_allocator::member);
   }
 
   /* retrieval of indices by number */

     BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
     typedef typename mpl::at_c<index_type_list,N>::type type;
   };
 
   template<int N>
-  typename nth_index<N>::type& get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+  typename nth_index<N>::type& get()BOOST_NOEXCEPT
   {
     BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
     return *this;
   }
 
   template<int N>
-  const typename nth_index<N>::type& get(
-    BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
+  const typename nth_index<N>::type& get()const BOOST_NOEXCEPT
   {
     BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
     return *this;
   }
 #endif

 
     typedef typename mpl::deref<iter>::type    type;
   };
 
   template<typename Tag>
-  typename index<Tag>::type& get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))
+  typename index<Tag>::type& get()BOOST_NOEXCEPT
   {
     return *this;
   }
 
   template<typename Tag>
-  const typename index<Tag>::type& get(
-    BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))const
+  const typename index<Tag>::type& get()const BOOST_NOEXCEPT
   {
     return *this;
   }
 #endif
 

   {
     typedef typename nth_index<N>::type::const_iterator type;
   };
 
   template<int N,typename IteratorType>
-  typename nth_index_iterator<N>::type project(
-    IteratorType it
-    BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
-  {
-    typedef typename nth_index<N>::type index;
+  typename nth_index_iterator<N>::type project(IteratorType it)
+  {
+    typedef typename nth_index<N>::type index_type;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT(
       (mpl::contains<iterator_type_list,IteratorType>::value));
 #endif
 
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<typename IteratorType::container_type&>(*this));
 
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 
   template<int N,typename IteratorType>
-  typename nth_index_const_iterator<N>::type project(
-    IteratorType it
-    BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
-  {
-    typedef typename nth_index<N>::type index;
+  typename nth_index_const_iterator<N>::type project(IteratorType it)const
+  {
+    typedef typename nth_index<N>::type index_type;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT((
       mpl::contains<iterator_type_list,IteratorType>::value||
       mpl::contains<const_iterator_type_list,IteratorType>::value));
 #endif
 
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 #endif
 
   /* projection of iterators by tag */
 

   {
     typedef typename index<Tag>::type::const_iterator type;
   };
 
   template<typename Tag,typename IteratorType>
-  typename index_iterator<Tag>::type project(
-    IteratorType it
-    BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
-  {
-    typedef typename index<Tag>::type index;
+  typename index_iterator<Tag>::type project(IteratorType it)
+  {
+    typedef typename index<Tag>::type index_type;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT(
       (mpl::contains<iterator_type_list,IteratorType>::value));
 #endif
 
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 
   template<typename Tag,typename IteratorType>
-  typename index_const_iterator<Tag>::type project(
-    IteratorType it
-    BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
-  {
-    typedef typename index<Tag>::type index;
+  typename index_const_iterator<Tag>::type project(IteratorType it)const
+  {
+    typedef typename index<Tag>::type index_type;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT((
       mpl::contains<iterator_type_list,IteratorType>::value||
       mpl::contains<const_iterator_type_list,IteratorType>::value));
 #endif
 
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 #endif
 
 BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
   typedef typename super::copy_map_type copy_map_type;

   }
 
   template<typename Variant>
   std::pair<node_type*,bool> insert_(const Value& v,Variant variant)
   {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      node_type* res=super::insert_(v,x,variant);
-      if(res==x){
-        ++node_count;
-        return std::pair<node_type*,bool>(res,true);
-      }
-      else{
-        deallocate_node(x);
-        return std::pair<node_type*,bool>(res,false);
-      }
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
+    node_type* x=0;
+    node_type* res=super::insert_(v,x,variant);
+    if(res==x){
+      ++node_count;
+      return std::pair<node_type*,bool>(res,true);
+    }
+    else{
+      return std::pair<node_type*,bool>(res,false);
+    }
   }
 
   std::pair<node_type*,bool> insert_(const Value& v)
   {
     return insert_(v,detail::lvalue_tag());

 
   template<typename Variant>
   std::pair<node_type*,bool> insert_(
     const Value& v,node_type* position,Variant variant)
   {
-    node_type* x=allocate_node();
-    BOOST_TRY{
-      node_type* res=super::insert_(v,position,x,variant);
-      if(res==x){
-        ++node_count;
-        return std::pair<node_type*,bool>(res,true);
-      }
-      else{
-        deallocate_node(x);
-        return std::pair<node_type*,bool>(res,false);
-      }
-    }
-    BOOST_CATCH(...){
-      deallocate_node(x);
-      BOOST_RETHROW;
-    }
-    BOOST_CATCH_END
+    node_type* x=0;
+    node_type* res=super::insert_(v,position,x,variant);
+    if(res==x){
+      ++node_count;
+      return std::pair<node_type*,bool>(res,true);
+    }
+    else{
+      return std::pair<node_type*,bool>(res,false);
+    }
   }
 
   std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
   {
     return insert_(v,position,detail::lvalue_tag());

     }
     BOOST_CATCH_END
   }
 
   template<typename Modifier,typename Rollback>
-  bool modify_(Modifier& mod,Rollback& back,node_type* x)
+  bool modify_(Modifier& mod,Rollback& back_,node_type* x)
   {
     mod(const_cast<value_type&>(x->value()));
 
     bool b;
     BOOST_TRY{
       b=super::modify_rollback_(x);
     }
     BOOST_CATCH(...){
       BOOST_TRY{
-        back(const_cast<value_type&>(x->value()));
+        back_(const_cast<value_type&>(x->value()));
         BOOST_RETHROW;
       }
       BOOST_CATCH(...){
         this->erase_(x);
         BOOST_RETHROW;

     }
     BOOST_CATCH_END
 
     BOOST_TRY{
       if(!b){
-        back(const_cast<value_type&>(x->value()));
+        back_(const_cast<value_type&>(x->value()));
         return false;
       }
       else return true;
     }
     BOOST_CATCH(...){

   typedef typename super::index_loader_type       index_loader_type;
 
   template<class Archive>
   void save(Archive& ar,const unsigned int version)const
   {
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     const serialization::collection_size_type       s(size_());
     const detail::serialization_version<value_type> value_version;
     ar<<serialization::make_nvp("count",s);
     ar<<serialization::make_nvp("value_version",value_version);
-#else
-    const std::size_t  s=size_();
-    const unsigned int value_version=0;
-    ar<<serialization::make_nvp("count",s);
-#endif
 
     index_saver_type sm(bfm_allocator::member,s);
 
     for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
       serialization::save_construct_data_adl(ar,&*it,value_version);

   void load(Archive& ar,const unsigned int version)
   {
     BOOST_MULTI_INDEX_CHECK_INVARIANT;
 
     clear_(); 
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     serialization::collection_size_type       s;
     detail::serialization_version<value_type> value_version;
     if(version<1){
       std::size_t sz;
       ar>>serialization::make_nvp("count",sz);

       value_version=0;
     }
     else{
       ar>>serialization::make_nvp("value_version",value_version);
     }
-#else
-    std::size_t  s;
-    unsigned int value_version=0;
-    ar>>serialization::make_nvp("count",s);
-#endif
 
     index_loader_type lm(bfm_allocator::member,s);
 
     for(std::size_t n=0;n<s;++n){
       detail::archive_constructed<Value> value("item",ar,value_version);

 
 template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
 typename nth_index<
   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
 get(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m
-  BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>    multi_index_type;
   typedef typename nth_index<
     multi_index_container<
       Value,IndexSpecifierList,Allocator>,
     N
-  >::type                                  index;
+  >::type                                  index_type;
 
   BOOST_STATIC_ASSERT(N>=0&&
     N<
     mpl::size<
       BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
     >::type::value);
 
-  return detail::converter<multi_index_type,index>::index(m);
+  return detail::converter<multi_index_type,index_type>::index(m);
 }
 
 template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
 const typename nth_index<
   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
 get(
   const multi_index_container<Value,IndexSpecifierList,Allocator>& m
-  BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+)BOOST_NOEXCEPT
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>    multi_index_type;
   typedef typename nth_index<
     multi_index_container<
       Value,IndexSpecifierList,Allocator>,
     N
-  >::type                                  index;
+  >::type                                  index_type;
 
   BOOST_STATIC_ASSERT(N>=0&&
     N<
     mpl::size<
       BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
     >::type::value);
 
-  return detail::converter<multi_index_type,index>::index(m);
+  return detail::converter<multi_index_type,index_type>::index(m);
 }
 
 /* retrieval of indices by tag */
 
 template<typename MultiIndexContainer,typename Tag>

   typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
 >
 typename ::boost::multi_index::index<
   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
 get(
-  multi_index_container<Value,IndexSpecifierList,Allocator>& m
-  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+  multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>         multi_index_type;
   typedef typename ::boost::multi_index::index<
     multi_index_container<
       Value,IndexSpecifierList,Allocator>,
     Tag
-  >::type                                       index;
-
-  return detail::converter<multi_index_type,index>::index(m);
+  >::type                                       index_type;
+
+  return detail::converter<multi_index_type,index_type>::index(m);
 }
 
 template<
   typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
 >
 const typename ::boost::multi_index::index<
   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
 get(
   const multi_index_container<Value,IndexSpecifierList,Allocator>& m
-  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+)BOOST_NOEXCEPT
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>         multi_index_type;
   typedef typename ::boost::multi_index::index<
     multi_index_container<
       Value,IndexSpecifierList,Allocator>,
     Tag
-  >::type                                       index;
-
-  return detail::converter<multi_index_type,index>::index(m);
+  >::type                                       index_type;
+
+  return detail::converter<multi_index_type,index_type>::index(m);
 }
 
 /* projection of iterators by number */
 
 template<typename MultiIndexContainer,int N>
 struct nth_index_iterator
 {
-  typedef typename detail::prevent_eti<
-    nth_index<MultiIndexContainer,N>,
-    typename nth_index<MultiIndexContainer,N>::type>::type::iterator type;
+  typedef typename nth_index<MultiIndexContainer,N>::type::iterator type;
 };
 
 template<typename MultiIndexContainer,int N>
 struct nth_index_const_iterator
 {
-  typedef typename detail::prevent_eti<
-    nth_index<MultiIndexContainer,N>,
-    typename nth_index<MultiIndexContainer,N>::type
-  >::type::const_iterator type;
+  typedef typename nth_index<MultiIndexContainer,N>::type::const_iterator type;
 };
 
 template<
   int N,typename IteratorType,
   typename Value,typename IndexSpecifierList,typename Allocator>
 typename nth_index_iterator<
   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
 project(
   multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it
-  BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+  IteratorType it)
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>                multi_index_type;
-  typedef typename nth_index<multi_index_type,N>::type index;
-
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&&  /* MSVC++ 6.0/7.0 fails */\
-    (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7  */
+  typedef typename nth_index<multi_index_type,N>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
   BOOST_STATIC_ASSERT((
     mpl::contains<
       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
       IteratorType>::value));
 #endif

     multi_index_type,
     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
 #endif
 
-  return detail::converter<multi_index_type,index>::iterator(
+  return detail::converter<multi_index_type,index_type>::iterator(
     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
 }
 
 template<
   int N,typename IteratorType,
   typename Value,typename IndexSpecifierList,typename Allocator>
 typename nth_index_const_iterator<
   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
 project(
   const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it
-  BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
+  IteratorType it)
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>                multi_index_type;
-  typedef typename nth_index<multi_index_type,N>::type index;
-
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&&  /* MSVC++ 6.0/7.0 fails */\
-    (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7  */
+  typedef typename nth_index<multi_index_type,N>::type index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
   BOOST_STATIC_ASSERT((
     mpl::contains<
       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
       IteratorType>::value||
     mpl::contains<

     multi_index_type,
     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
 #endif
 
-  return detail::converter<multi_index_type,index>::const_iterator(
+  return detail::converter<multi_index_type,index_type>::const_iterator(
     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
 }
 
 /* projection of iterators by tag */
 

   typename Value,typename IndexSpecifierList,typename Allocator>
 typename index_iterator<
   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
 project(
   multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it
-  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+  IteratorType it)
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>         multi_index_type;
   typedef typename ::boost::multi_index::index<
-    multi_index_type,Tag>::type                 index;
-
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&&  /* MSVC++ 6.0/7.0 fails */\
-    (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7  */
+    multi_index_type,Tag>::type                 index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
   BOOST_STATIC_ASSERT((
     mpl::contains<
       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
       IteratorType>::value));
 #endif

     multi_index_type,
     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
 #endif
 
-  return detail::converter<multi_index_type,index>::iterator(
+  return detail::converter<multi_index_type,index_type>::iterator(
     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
 }
 
 template<
   typename Tag,typename IteratorType,
   typename Value,typename IndexSpecifierList,typename Allocator>
 typename index_const_iterator<
   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
 project(
   const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
-  IteratorType it
-  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
+  IteratorType it)
 {
   typedef multi_index_container<
     Value,IndexSpecifierList,Allocator>         multi_index_type;
   typedef typename ::boost::multi_index::index<
-    multi_index_type,Tag>::type                 index;
-
-#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&&  /* MSVC++ 6.0/7.0 fails */\
-    (!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7  */
+    multi_index_type,Tag>::type                 index_type;
+
+#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
   BOOST_STATIC_ASSERT((
     mpl::contains<
       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
       IteratorType>::value||
     mpl::contains<

     multi_index_type,
     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
 #endif
 
-  return detail::converter<multi_index_type,index>::const_iterator(
+  return detail::converter<multi_index_type,index_type>::const_iterator(
     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
 }
 
 /* Comparison. Simple forward to first index. */
 

   x.swap(y);
 }
 
 } /* namespace multi_index */
 
-#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)&&\
-    !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
 /* class version = 1 : we now serialize the size through
  * boost::serialization::collection_size_type.
  * class version = 2 : proper use of {save|load}_construct_data.
  */