import new upstream nautilus stable release 14.2.8

[ceph.git] / ceph / src / boost / libs / multi_index / test / test_key_extractors.cpp

diff --git a/ceph/src/boost/libs/multi_index/test/test_key_extractors.cpp b/ceph/src/boost/libs/multi_index/test/test_key_extractors.cpp
index 33111d1e89778916554864fbba69347e3f547460..95643df941dd1264fb1a26d78aad83b709b6138c 100644 (file)
--- a/ceph/src/boost/libs/multi_index/test/test_key_extractors.cpp
+++ b/ceph/src/boost/libs/multi_index/test/test_key_extractors.cpp
@@ -1,6 +1,6 @@
 /* Boost.MultiIndex test for key extractors.
  *
- * Copyright 2003-2015 Joaquin M Lopez Munoz.
+ * Copyright 2003-2019 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)
@@ -28,6 +28,17 @@ struct test_class
 
   bool bool_mem_fun_const()const{return true;}
   bool bool_mem_fun(){return false;}
+  bool bool_mem_fun_volatile()volatile{return false;}
+  bool bool_mem_fun_cv()const volatile{return true;}
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+
+  bool bool_mem_fun_cref()const&{return true;}
+  bool bool_mem_fun_ref()&{return false;}
+  bool bool_mem_fun_vref()volatile&{return false;}
+  bool bool_mem_fun_cvref()const volatile&{return true;}
+
+#endif
 
   static bool bool_global_fun(test_class){return true;}
   static bool bool_global_fun_const_ref(const test_class&){return false;}
@@ -66,9 +77,25 @@ typedef identity<const test_class>                                 cidn;
 typedef BOOST_MULTI_INDEX_MEMBER(test_class,int,int_member)        key_m;
 typedef BOOST_MULTI_INDEX_MEMBER(test_class,const int,int_member)  ckey_m;
 typedef BOOST_MULTI_INDEX_MEMBER(test_class,const int,int_cmember) key_cm;
+typedef BOOST_MULTI_INDEX_MEM_FUN(test_class,bool,bool_mem_fun)    key_mf;
 typedef BOOST_MULTI_INDEX_CONST_MEM_FUN(
           test_class,bool,bool_mem_fun_const)                      key_cmf;
-typedef BOOST_MULTI_INDEX_MEM_FUN(test_class,bool,bool_mem_fun)    key_mf;
+typedef volatile_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_volatile>      key_vmf;
+typedef cv_mem_fun<test_class,bool,&test_class::bool_mem_fun_cv>   key_cvmf;
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+
+typedef cref_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_cref>          key_crmf;
+typedef ref_mem_fun<test_class,bool,&test_class::bool_mem_fun_ref> key_rmf;
+typedef vref_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_vref>          key_vrmf;
+typedef cvref_mem_fun<
+          test_class,bool,&test_class::bool_mem_fun_cvref>         key_cvrmf;
+
+#endif
+
 typedef global_fun<test_class,bool,&test_class::bool_global_fun>   key_gf;
 typedef global_fun<
           const test_class&,bool,
@@ -165,6 +192,14 @@ void test_key_extractors()
   key_cm     k_cm;
   key_cmf    k_cmf;
   key_mf     k_mf;
+  key_vmf    k_vmf;
+  key_cvmf   k_cvmf;
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  key_crmf   k_crmf;
+  key_rmf    k_rmf;
+  key_vrmf   k_vrmf;
+  key_cvrmf  k_cvrmf;
+#endif
   key_gf     k_gf;
   key_gcrf   k_gcrf;
   key_grf    k_grf;
@@ -313,43 +348,139 @@ void test_key_extractors()
 
   BOOST_TEST(k_cmf(tr));
   BOOST_TEST(k_cmf(ctr));
+  BOOST_TEST(k_cvmf(tr));
+  BOOST_TEST(k_cvmf(ctr));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tr));
+  BOOST_TEST(k_crmf(ctr));
+  BOOST_TEST(k_cvrmf(tr));
+  BOOST_TEST(k_cvrmf(ctr));
+#endif
 
 #if !defined(BOOST_NO_SFINAE)
   BOOST_TEST(k_cmf(td));
   BOOST_TEST(k_cmf(ctdr));
+  BOOST_TEST(k_cvmf(td));
+  BOOST_TEST(k_cvmf(ctdr));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(td));
+  BOOST_TEST(k_crmf(ctdr));
+  BOOST_TEST(k_cvrmf(td));
+  BOOST_TEST(k_cvrmf(ctdr));
+#endif
 #endif
 
   BOOST_TEST(k_cmf(tp));
   BOOST_TEST(k_cmf(ctp));
+  BOOST_TEST(k_cvmf(tp));
+  BOOST_TEST(k_cvmf(ctp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tp));
+  BOOST_TEST(k_crmf(ctp));
+  BOOST_TEST(k_cvrmf(tp));
+  BOOST_TEST(k_cvrmf(ctp));
+#endif
 
 #if !defined(BOOST_NO_SFINAE)
   BOOST_TEST(k_cmf(tdp));
   BOOST_TEST(k_cmf(ctdp));
+  BOOST_TEST(k_cvmf(tdp));
+  BOOST_TEST(k_cvmf(ctdp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tdp));
+  BOOST_TEST(k_crmf(ctdp));
+  BOOST_TEST(k_cvrmf(tdp));
+  BOOST_TEST(k_cvrmf(ctdp));
+#endif
 #endif
 
   BOOST_TEST(k_cmf(tpp));
   BOOST_TEST(k_cmf(ctpp));
   BOOST_TEST(k_cmf(tap));
   BOOST_TEST(k_cmf(ctap));
+  BOOST_TEST(k_cvmf(tpp));
+  BOOST_TEST(k_cvmf(ctpp));
+  BOOST_TEST(k_cvmf(tap));
+  BOOST_TEST(k_cvmf(ctap));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tpp));
+  BOOST_TEST(k_crmf(ctpp));
+  BOOST_TEST(k_crmf(tap));
+  BOOST_TEST(k_crmf(ctap));
+  BOOST_TEST(k_cvrmf(tpp));
+  BOOST_TEST(k_cvrmf(ctpp));
+  BOOST_TEST(k_cvrmf(tap));
+  BOOST_TEST(k_cvrmf(ctap));
+#endif
 
   BOOST_TEST(k_cmf(tw));
   BOOST_TEST(k_cmf(ctw));
+  BOOST_TEST(k_cvmf(tw));
+  BOOST_TEST(k_cvmf(ctw));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(k_crmf(tw));
+  BOOST_TEST(k_crmf(ctw));
+  BOOST_TEST(k_cvrmf(tw));
+  BOOST_TEST(k_cvrmf(ctw));
+#endif
 
   BOOST_TEST(!k_mf(tr));
+  BOOST_TEST(!k_vmf(tr));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tr));
+  BOOST_TEST(!k_vrmf(tr));
+#endif
 
 #if !defined(BOOST_NO_SFINAE)
   BOOST_TEST(!k_mf(td));
+  BOOST_TEST(!k_vmf(td));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(td));
+  BOOST_TEST(!k_vrmf(td));
+#endif
 #endif
 
   BOOST_TEST(!k_mf(tp));
+  BOOST_TEST(!k_vmf(tp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tp));
+  BOOST_TEST(!k_vrmf(tp));
+#endif
 
 #if !defined(BOOST_NO_SFINAE)
   BOOST_TEST(!k_mf(tdp));
+  BOOST_TEST(!k_vmf(tdp));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tdp));
+  BOOST_TEST(!k_vrmf(tdp));
+#endif
 #endif
 
   BOOST_TEST(!k_mf(tpp));
   BOOST_TEST(!k_mf(tap));
   BOOST_TEST(!k_mf(tw));
+  BOOST_TEST(!k_vmf(tpp));
+  BOOST_TEST(!k_vmf(tap));
+  BOOST_TEST(!k_vmf(tw));
+
+#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+  BOOST_TEST(!k_rmf(tpp));
+  BOOST_TEST(!k_rmf(tap));
+  BOOST_TEST(!k_rmf(tw));
+  BOOST_TEST(!k_vrmf(tpp));
+  BOOST_TEST(!k_vrmf(tap));
+  BOOST_TEST(!k_vrmf(tw));
+#endif
 
   BOOST_TEST(k_gf(tr));
   BOOST_TEST(k_gf(ctr));