import new upstream nautilus stable release 14.2.8

[ceph.git] / ceph / src / boost / boost / multiprecision / traits / explicit_conversion.hpp

diff --git a/ceph/src/boost/boost/multiprecision/traits/explicit_conversion.hpp b/ceph/src/boost/boost/multiprecision/traits/explicit_conversion.hpp
index 0a14f03442fcc6d1f93dcd31861a0c3647958201..9f99f764c88b6b8d20c007ad9ff16a71fffdd235 100644 (file)
--- a/ceph/src/boost/boost/multiprecision/traits/explicit_conversion.hpp
+++ b/ceph/src/boost/boost/multiprecision/traits/explicit_conversion.hpp
@@ -7,84 +7,83 @@
 #ifndef BOOST_MP_EXPLICIT_CONVERTIBLE_HPP
 #define BOOST_MP_EXPLICIT_CONVERTIBLE_HPP
 
+#include <boost/config.hpp>
+#include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#include <boost/utility/declval.hpp>
-
+#include <boost/type_traits/declval.hpp>
+#include <boost/multiprecision/detail/number_base.hpp> // number_category
 
 namespace boost {
-   namespace multiprecision {
-      namespace detail {
+namespace multiprecision {
+namespace detail {
 
-         template <int N>
-         struct dummy_size {};
+template <unsigned int N>
+struct dummy_size
+{};
 
-         template<typename S, typename T>
-         struct has_generic_interconversion
-         {
-            typedef typename mpl::if_c <
-               is_number<S>::value && is_number<T>::value,
-               typename mpl::if_c <
-               number_category<S>::value == number_kind_integer,
-               typename mpl::if_c<
-               number_category<T>::value == number_kind_integer
-               || number_category<T>::value == number_kind_floating_point
-               || number_category<T>::value == number_kind_rational
-               || number_category<T>::value == number_kind_fixed_point,
-               mpl::true_,
-               mpl::false_
-               >::type,
-               typename mpl::if_c<
+template <typename S, typename T>
+struct has_generic_interconversion
+{
+   typedef typename boost::conditional<
+       is_number<S>::value && is_number<T>::value,
+       typename boost::conditional<
+           number_category<S>::value == number_kind_integer,
+           typename boost::conditional<
+               number_category<T>::value == number_kind_integer || number_category<T>::value == number_kind_floating_point || number_category<T>::value == number_kind_rational || number_category<T>::value == number_kind_fixed_point,
+               boost::true_type,
+               boost::false_type>::type,
+           typename boost::conditional<
                number_category<S>::value == number_kind_rational,
-               typename mpl::if_c<
-               number_category<T>::value == number_kind_rational
-               || number_category<T>::value == number_kind_rational,
-               mpl::true_,
-               mpl::false_
-               >::type,
-               typename mpl::if_c<
-               number_category<T>::value == number_kind_floating_point,
-               mpl::true_,
-               mpl::false_
-               >::type
-               >::type
-               > ::type,
-               mpl::false_
-            > ::type type;
-         };
+               typename boost::conditional<
+                   number_category<T>::value == number_kind_rational || number_category<T>::value == number_kind_rational,
+                   boost::true_type,
+                   boost::false_type>::type,
+               typename boost::conditional<
+                   number_category<T>::value == number_kind_floating_point,
+                   boost::true_type,
+                   boost::false_type>::type>::type>::type,
+       boost::false_type>::type type;
+};
 
-         template<typename S, typename T>
-         struct is_explicitly_convertible_imp
-         {
+template <typename S, typename T>
+struct is_explicitly_convertible_imp
+{
 #ifndef BOOST_NO_SFINAE_EXPR
-            template<typename S1, typename T1>
-            static type_traits::yes_type selector(dummy_size<sizeof(static_cast<T1>(declval<S1>()))>*);
+   template <typename S1, typename T1>
+   static type_traits::yes_type selector(dummy_size<sizeof(new T1(boost::declval<
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+                                                                  S1
+#else
+                                                                  S1 const&
+#endif
+                                                                  >()))>*);
 
-            template<typename S1, typename T1>
-            static type_traits::no_type selector(...);
+   template <typename S1, typename T1>
+   static type_traits::no_type selector(...);
 
-            static const bool value = sizeof(selector<S, T>(0)) == sizeof(type_traits::yes_type);
+   static const bool value = sizeof(selector<S, T>(0)) == sizeof(type_traits::yes_type);
 
-            typedef boost::integral_constant<bool, value> type;
+   typedef boost::integral_constant<bool, value> type;
 #else
-            typedef typename has_generic_interconversion<S, T>::type gen_type;
-            typedef mpl::bool_<boost::is_convertible<S, T>::value || gen_type::value> type;
+   typedef typename has_generic_interconversion<S, T>::type                                      gen_type;
+   typedef boost::integral_constant<bool, boost::is_convertible<S, T>::value || gen_type::value> type;
 #endif
-         };
+};
 
-template<typename From, typename To>
+template <typename From, typename To>
 struct is_explicitly_convertible : public is_explicitly_convertible_imp<From, To>::type
 {
 };
 
 #ifdef BOOST_NO_SFINAE_EXPR
-template<class Backend1, expression_template_option ExpressionTemplates1, class Backend2, expression_template_option ExpressionTemplates2>
+template <class Backend1, expression_template_option ExpressionTemplates1, class Backend2, expression_template_option ExpressionTemplates2>
 struct is_explicitly_convertible<number<Backend1, ExpressionTemplates1>, number<Backend2, ExpressionTemplates2> >
-   : public is_explicitly_convertible<Backend1, Backend2>
+    : public is_explicitly_convertible<Backend1, Backend2>
 {
 };
 #endif
 
-}}} // namespaces
+}}} // namespace boost::multiprecision::detail
 
 #endif
-