//remove_reference.h 
#ifndef _REMOVE_REFERENCE_H_ 
#define _REMOVE_REFERENCE_H_ 
 
namespace boost { 
 
namespace type_traits { 
     
    template < class T>  struct wrap {}; 
 
    typedef  char yes_type; 
     struct no_type 
    { 
       char padding[8]; 
    }; 
     
} // namespace boost::type_traits 
 
namespace detail { 
    
   using ::boost::type_traits::yes_type; 
   using ::boost::type_traits::no_type; 
   using ::boost::type_traits::wrap; 
 
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \ 
  template<>  struct trait##_impl< sp > \ 
  { \ 
   enum {value = (C)}; \ 
  };    
    
  template < class T> T&(* is_reference_helper1(wrap<T>) )(wrap<T>); 
   char is_reference_helper1(...); 
    
  template < class T> no_type is_reference_helper2(T&(*)(wrap<T>)); 
  yes_type is_reference_helper2(...); 
    
  template <typename T> 
     struct is_reference_impl 
  { 
     enum{ 
      value =  sizeof( 
        ::boost::detail::is_reference_helper2( 
        ::boost::detail::is_reference_helper1(::boost::type_traits::wrap<T>()))) == 1 
    }; 
     //      BOOST_STATIC_CONSTANT( 
     //        bool, value = sizeof( 
     //                         ::boost::detail::is_reference_helper2( 
     //        ::boost::detail::is_reference_helper1(::boost::type_traits::wrap<T>()))) == 1 
     //        ); 
  }; 
 
    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference, void, false)  // VC6用这一个就可以了，void const等也解决了 
//    #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS 
//    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const,false) 
//    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void volatile,false) 
//    BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const volatile,false) 
//    #endif 
     
}  // namespace detail 
 
template <typename T> 
struct is_reference 
{ 
   enum{ 
    value = detail::is_reference_impl<T>::value 
  }; 
}; 
 
 
namespace detail { 
  template<typename ID> 
                 struct msvc_extract_type 
  { 
     struct id2type; 
  }; 
    
  template<typename T, typename ID> 
                 struct msvc_register_type : msvc_extract_type<ID> 
  { 
    typedef msvc_extract_type<ID> base_type; 
     struct base_type::id2type  // This uses nice VC6.5 and VC7.1 bugfeature 
    { 
      typedef T type; 
    }; 
        }; 
    
  template< bool IsReference> 
                 struct remove_reference_impl_typeof { 
    template<typename T,typename ID> 
                         struct inner { 
      typedef T type; 
    }; 
  }; 
  template<> 
                 struct remove_reference_impl_typeof< true> { 
    template<typename T,typename ID> 
                         struct inner { 
      template<typename U> 
                                 static msvc_register_type<U,ID> test(U&(*)()); 
       static msvc_register_type<T,ID> test(...); 
       //BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) )); 
       enum {register_test= sizeof(test( (T(*)())(NULL) ) )}; 
      typedef typename msvc_extract_type<ID>::id2type::type type; 
    }; 
  }; 
}  //namespace detail 
 
template<typename T> 
struct remove_reference { 
  typedef typename detail::remove_reference_impl_typeof< 
    boost::is_reference<T>::value 
                >::template inner<T,remove_reference<T> >::type type; 
   //BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_reference,T) 
        }; 
 
}    
 
#endif