meta_utils.hpp

Go to the documentation of this file.

//
// (C) Copyright Ion Gaztanaga 2012-2015.
// 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/move for documentation.
//
 
 
#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP
#define BOOST_MOVE_DETAIL_META_UTILS_HPP
 
#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/detail/workaround.hpp>  //forceinline
#include <boost/move/detail/meta_utils_core.hpp>
#include <cstddef>   //for std::size_t
 
//Small meta-typetraits to support move
 
namespace boost {
 
//Forward declare boost::rv
template <class T> class rv;
 
namespace move_detail {
 
//          is_different
template<class T, class U>
struct is_different
{
   static const bool value = !is_same<T, U>::value;
};
 
//             apply
template<class F, class Param>
struct apply
{
   typedef typename F::template apply<Param>::type type;
};
 
//             bool_
 
template< bool C_ >
struct bool_ : integral_constant<bool, C_>
{
     operator bool() const { return C_; }
   bool operator()() const { return C_; }
};
 
typedef bool_<true>        true_;
typedef bool_<false>       false_;
 
//              nat
struct nat{};
 
//          yes_type/no_type
typedef char yes_type;
 
struct no_type
{
   char _[2];
};
 
//            natify
template <class T> struct natify{};
 
//          remove_reference
template<class T>
struct remove_reference
{
   typedef T type;
};
 
template<class T>
struct remove_reference<T&>
{
   typedef T type;
};
 
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
template<class T>
struct remove_reference<T&&>
{
   typedef T type;
};
 
#else
 
template<class T>
struct remove_reference< rv<T> >
{
   typedef T type;
};
 
template<class T>
struct remove_reference< rv<T> &>
{
   typedef T type;
};
 
template<class T>
struct remove_reference< const rv<T> &>
{
   typedef T type;
};
 
#endif
 
//             remove_pointer
 
template< class T > struct remove_pointer                    { typedef T type;   };
template< class T > struct remove_pointer<T*>                { typedef T type;   };
template< class T > struct remove_pointer<T* const>          { typedef T type;   };
template< class T > struct remove_pointer<T* volatile>       { typedef T type;   };
template< class T > struct remove_pointer<T* const volatile> { typedef T type;   };
 
//             add_pointer
template< class T >
struct add_pointer
{
   typedef typename remove_reference<T>::type* type;
};
 
//             add_const
template<class T>
struct add_const
{
   typedef const T type;
};
 
template<class T>
struct add_const<T&>
{
   typedef const T& type;
};
 
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
template<class T>
struct add_const<T&&>
{
   typedef T&& type;
};
 
#endif
 
//      add_lvalue_reference
template<class T>
struct add_lvalue_reference
{  typedef T& type;  };
 
template<class T> struct add_lvalue_reference<T&>                 {  typedef T& type;  };
template<>        struct add_lvalue_reference<void>               {  typedef void type;   };
template<>        struct add_lvalue_reference<const void>         {  typedef const void type;  };
template<>        struct add_lvalue_reference<volatile void>      {  typedef volatile void type;   };
template<>        struct add_lvalue_reference<const volatile void>{  typedef const volatile void type;   };
 
template<class T>
struct add_const_lvalue_reference
{
   typedef typename remove_reference<T>::type         t_unreferenced;
   typedef typename add_const<t_unreferenced>::type   t_unreferenced_const;
   typedef typename add_lvalue_reference
      <t_unreferenced_const>::type                    type;
};
 
//             is_lvalue_reference
template<class T>
struct is_lvalue_reference
{
    static const bool value = false;
};
 
template<class T>
struct is_lvalue_reference<T&>
{
    static const bool value = true;
};
 
 
//             identity
template <class T>
struct identity
{
   typedef T type;
   typedef typename add_const_lvalue_reference<T>::type reference;
   reference operator()(reference t)
   {  return t;   }
};
 
//          is_class_or_union
template<class T>
struct is_class_or_union
{
   struct twochar { char dummy[2]; };
   template <class U>
   static char is_class_or_union_tester(void(U::*)(void));
   template <class U>
   static twochar is_class_or_union_tester(...);
   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
};
 
//             addressof
template<class T>
struct addr_impl_ref
{
   T & v_;
   BOOST_MOVE_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
   BOOST_MOVE_FORCEINLINE operator T& () const { return v_; }
 
   private:
   addr_impl_ref & operator=(const addr_impl_ref &);
};
 
template<class T>
struct addressof_impl
{
   BOOST_MOVE_FORCEINLINE static T * f( T & v, long )
   {
      return reinterpret_cast<T*>(
         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
   }
 
   BOOST_MOVE_FORCEINLINE static T * f( T * v, int )
   {  return v;  }
};
 
template<class T>
BOOST_MOVE_FORCEINLINE T * addressof( T & v )
{
   return ::boost::move_detail::addressof_impl<T>::f
      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
}
 
//          has_pointer_type
template <class T>
struct has_pointer_type
{
   struct two { char c[2]; };
   template <class U> static two test(...);
   template <class U> static char test(typename U::pointer* = 0);
   static const bool value = sizeof(test<T>(0)) == 1;
};
 
//           is_convertible
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
 
//use intrinsic since in MSVC
//overaligned types can't go through ellipsis
template <class T, class U>
struct is_convertible
{
   static const bool value = __is_convertible_to(T, U);
};
 
#else
 
template <class T, class U>
class is_convertible
{
   typedef typename add_lvalue_reference<T>::type t_reference;
   typedef char true_t;
   class false_t { char dummy[2]; };
   static false_t dispatch(...);
   static true_t  dispatch(U);
   static t_reference       trigger();
   public:
   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
};
 
#endif
 
template <class T, class U, bool IsSame = is_same<T, U>::value>
struct is_same_or_convertible
   : is_convertible<T, U>
{};
 
template <class T, class U>
struct is_same_or_convertible<T, U, true>
{
   static const bool value = true;
};
 
template<
      bool C
    , typename F1
    , typename F2
    >
struct eval_if_c
    : if_c<C,F1,F2>::type
{};
 
template<
      typename C
    , typename T1
    , typename T2
    >
struct eval_if
    : if_<C,T1,T2>::type
{};
 
 
#if defined(BOOST_GCC) && (BOOST_GCC <= 40000)
#define BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN
#endif
 
template<class T, class U, class R = void>
struct enable_if_convertible
   : enable_if< is_convertible<T, U>, R>
{};
 
template<class T, class U, class R = void>
struct disable_if_convertible
   : disable_if< is_convertible<T, U>, R>
{};
 
template<class T, class U, class R = void>
struct enable_if_same_or_convertible
   : enable_if< is_same_or_convertible<T, U>, R>
{};
 
template<class T, class U, class R = void>
struct disable_if_same_or_convertible
   : disable_if< is_same_or_convertible<T, U>, R>
{};
 
//
//                         and_
//
template<bool, class B = true_, class C = true_, class D = true_>
struct and_impl
   : and_impl<B::value, C, D>
{};
 
template<>
struct and_impl<true, true_, true_, true_>
{
   static const bool value = true;
};
 
template<class B, class C, class D>
struct and_impl<false, B, C, D>
{
   static const bool value = false;
};
 
template<class A, class B, class C = true_, class D = true_>
struct and_
   : and_impl<A::value, B, C, D>
{};
 
//
//                            or_
//
template<bool, class B = false_, class C = false_, class D = false_>
struct or_impl
   : or_impl<B::value, C, D>
{};
 
template<>
struct or_impl<false, false_, false_, false_>
{
   static const bool value = false;
};
 
template<class B, class C, class D>
struct or_impl<true, B, C, D>
{
   static const bool value = true;
};
 
template<class A, class B, class C = false_, class D = false_>
struct or_
   : or_impl<A::value, B, C, D>
{};
 
//
//                         not_
//
template<class T>
struct not_
{
   static const bool value = !T::value;
};
 
//
// enable_if_and / disable_if_and / enable_if_or / disable_if_or
//
 
template<class R, class A, class B, class C = true_, class D = true_>
struct enable_if_and
   : enable_if_c< and_<A, B, C, D>::value, R>
{};
 
template<class R, class A, class B, class C = true_, class D = true_>
struct disable_if_and
   : disable_if_c< and_<A, B, C, D>::value, R>
{};
 
template<class R, class A, class B, class C = false_, class D = false_>
struct enable_if_or
   : enable_if_c< or_<A, B, C, D>::value, R>
{};
 
template<class R, class A, class B, class C = false_, class D = false_>
struct disable_if_or
   : disable_if_c< or_<A, B, C, D>::value, R>
{};
 
//
//                      has_move_emulation_enabled_impl
//
template<class T>
struct has_move_emulation_enabled_impl
   : is_convertible< T, ::boost::rv<T>& >
{};
 
template<class T>
struct has_move_emulation_enabled_impl<T&>
{  static const bool value = false;  };
 
template<class T>
struct has_move_emulation_enabled_impl< ::boost::rv<T> >
{  static const bool value = false;  };
 
//
//                            is_rv_impl
//
 
template <class T>
struct is_rv_impl
{  static const bool value = false;  };
 
template <class T>
struct is_rv_impl< rv<T> >
{  static const bool value = true;  };
 
template <class T>
struct is_rv_impl< const rv<T> >
{  static const bool value = true;  };
 
// Code from Jeffrey Lee Hellrung, many thanks
 
template< class T >
struct is_rvalue_reference
{  static const bool value = false;  };
 
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
template< class T >
struct is_rvalue_reference< T&& >
{  static const bool value = true;  };
 
#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
template< class T >
struct is_rvalue_reference< boost::rv<T>& >
{  static const bool value = true;  };
 
template< class T >
struct is_rvalue_reference< const boost::rv<T>& >
{  static const bool value = true;  };
 
#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
template< class T >
struct add_rvalue_reference
{ typedef T&& type; };
 
#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
namespace detail_add_rvalue_reference
{
   template< class T
            , bool emulation = has_move_emulation_enabled_impl<T>::value
            , bool rv        = is_rv_impl<T>::value  >
   struct add_rvalue_reference_impl { typedef T type; };
 
   template< class T, bool emulation>
   struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };
 
   template< class T, bool rv >
   struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
} // namespace detail_add_rvalue_reference
 
template< class T >
struct add_rvalue_reference
   : detail_add_rvalue_reference::add_rvalue_reference_impl<T>
{ };
 
template< class T >
struct add_rvalue_reference<T &>
{  typedef T & type; };
 
#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
template< class T > struct remove_rvalue_reference { typedef T type; };
 
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   template< class T > struct remove_rvalue_reference< T&& >                  { typedef T type; };
#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
   template< class T > struct remove_rvalue_reference< rv<T> >                { typedef T type; };
   template< class T > struct remove_rvalue_reference< const rv<T> >          { typedef T type; };
   template< class T > struct remove_rvalue_reference< volatile rv<T> >       { typedef T type; };
   template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
   template< class T > struct remove_rvalue_reference< rv<T>& >               { typedef T type; };
   template< class T > struct remove_rvalue_reference< const rv<T>& >         { typedef T type; };
   template< class T > struct remove_rvalue_reference< volatile rv<T>& >      { typedef T type; };
   template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };
#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
// Ideas from Boost.Move review, Jeffrey Lee Hellrung:
//
//- TypeTraits metafunctions is_lvalue_reference, add_lvalue_reference, and remove_lvalue_reference ?
//  Perhaps add_reference and remove_reference can be modified so that they behave wrt emulated rvalue
//  references the same as wrt real rvalue references, i.e., add_reference< rv<T>& > -> T& rather than
//  rv<T>& (since T&& & -> T&).
//
//- Add'l TypeTraits has_[trivial_]move_{constructor,assign}...?
//
//- An as_lvalue(T& x) function, which amounts to an identity operation in C++0x, but strips emulated
//  rvalue references in C++03.  This may be necessary to prevent "accidental moves".
 
}  //namespace move_detail {
}  //namespace boost {
 
#include <boost/move/detail/config_end.hpp>
 
#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP