Merge branch 'develop'

Changes for Embarcadero C++ clang-based compilers, targeting Boost 1.74

include/boost/tuple/detail/tuple_basic.hpp

@@ -37,6 +37,7 @@
 
 #include <boost/type_traits/cv_traits.hpp>
 #include <boost/type_traits/function_traits.hpp>
+#include <boost/type_traits/integral_constant.hpp>
 #include <boost/utility/swap.hpp>
 
 #include <boost/detail/workaround.hpp> // needed for BOOST_WORKAROUND
@@ -140,7 +141,7 @@ private:
   typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
       apply<T>::type::head_type unqualified_type;
 public:
-#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+#if BOOST_WORKAROUND(BOOST_BORLANDC,<0x600)
   typedef const unqualified_type type;
 #else
   typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
@@ -309,6 +310,7 @@ struct cons {
       tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
       {}
 
+  cons( const cons& u ) : head(u.head), tail(u.tail) {}
 
   template <class HT2, class TT2>
   cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
@@ -388,6 +390,8 @@ struct cons<HT, null_type> {
        const null_type&, const null_type&, const null_type&)
   : head () {}
 
+  cons( const cons& u ) : head(u.head) {}
+
   template <class HT2>
   cons( const cons<HT2, null_type>& u ) : head(u.head) {}
 
@@ -420,28 +424,28 @@ struct cons<HT, null_type> {
 // templates for finding out the length of the tuple -------------------
 
 template<class T>
-struct length  {
-  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
+struct length: boost::integral_constant<int, 1 + length<typename T::tail_type>::value>
+{
 };
 
 template<>
-struct length<tuple<> > {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<tuple<> >: boost::integral_constant<int, 0>
+{
 };
 
 template<>
-struct length<tuple<> const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<tuple<> const>: boost::integral_constant<int, 0>
+{
 };
 
 template<>
-struct length<null_type> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<null_type>: boost::integral_constant<int, 0>
+{
 };
 
 template<>
-struct length<null_type const> {
-  BOOST_STATIC_CONSTANT(int, value = 0);
+struct length<null_type const>: boost::integral_constant<int, 0>
+{
 };
 
 namespace detail {

include/boost/tuple/tuple.hpp

@@ -63,5 +63,56 @@ get(const tuples::cons<HT, TT>& c) {
 
 } // end namespace boost
 
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+#include <tuple>
+#include <cstddef>
+
+namespace std
+{
+
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+
+// std::tuple_size
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
+    class tuple_size< boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >:
+        public boost::tuples::length< boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+{
+};
+
+template<class H, class T> class tuple_size< boost::tuples::cons<H, T> >:
+    public boost::tuples::length< boost::tuples::cons<H, T> >
+{
+};
+
+template<> class tuple_size< boost::tuples::null_type >:
+    public boost::tuples::length< boost::tuples::null_type >
+{
+};
+
+// std::tuple_element
+
+template<std::size_t I, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
+    class tuple_element< I, boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >:
+        public boost::tuples::element< I, boost::tuples::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+{
+};
+
+template<std::size_t I, class H, class T> class tuple_element< I, boost::tuples::cons<H, T> >:
+    public boost::tuples::element< I, boost::tuples::cons<H, T> >
+{
+};
+
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic pop
+#endif
+
+} // namespace std
+
+#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE)
 
 #endif // BOOST_TUPLE_HPP

include/boost/tuple/tuple_io.hpp

@@ -102,7 +102,7 @@ class tuple_manipulator {
   CharType f_c;
 public:
   explicit tuple_manipulator(detail::format_info::manipulator_type m,
-                             const char c = 0)
+                             CharType c = CharType())
      : mt(m), f_c(c) {}
 
    template<class CharTrait>
@@ -259,7 +259,7 @@ extract_and_check_delimiter(
 
 #if defined (BOOST_NO_STD_LOCALE)
   const bool is_delimiter = !isspace(d);
-#elif defined ( __BORLANDC__ )
+#elif defined ( BOOST_BORLANDC )
   const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
     (is.getloc() ).is( std::ctype_base::space, d);
 #else

test/Jamfile

@@ -1,8 +1,11 @@
-
-project : requirements <library>/boost/test//boost_test_exec_monitor ;
+# Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+# Distributed under the Boost Software License, Version 1.0.
 
 test-suite tuple : 
     [ run tuple_test_bench.cpp ]
     [ run io_test.cpp ]
     [ run another_tuple_test_bench.cpp ]
-    ;
+    [ run std_tuple_size.cpp ]
+    [ run std_tuple_element.cpp ]
+    [ run structured_bindings.cpp ]
+    ;

test/another_tuple_test_bench.cpp

@@ -15,11 +15,10 @@
 // Defining any of E1 to E5 or E7 to E11 opens some illegal code that 
 // should cause the compliation to fail.
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
 #include "boost/tuple/tuple.hpp"
 
+#include "boost/core/lightweight_test.hpp"
+
 #include <string>
 #include <utility>
 
@@ -149,7 +148,7 @@ void foo7() {
 
 // --------------------------------
 // ----------------------------
-int test_main(int, char *[]) {
+int main() {
 
   foo1();
   foo2();
@@ -159,5 +158,5 @@ int test_main(int, char *[]) {
 
   foo7();
 
-  return 0;
+  return boost::report_errors();
 }

test/io_test.cpp

@@ -10,12 +10,11 @@
 //
 // Testing the I/O facilities of tuples
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include "boost/test/test_tools.hpp"    // see "Header Implementation Option"
-
 #include "boost/tuple/tuple_io.hpp"
 #include "boost/tuple/tuple_comparison.hpp"
 
+#include "boost/core/lightweight_test.hpp"
+
 #include <fstream>
 #include <iterator>
 #include <algorithm>
@@ -28,6 +27,8 @@
 #include <sstream>
 #endif
 
+#define BOOST_CHECK BOOST_TEST
+
 using namespace boost;
 
 #if defined BOOST_NO_STRINGSTREAM
@@ -38,9 +39,7 @@ typedef std::ostringstream useThisOStringStream;
 typedef std::istringstream useThisIStringStream;
 #endif
 
-int test_main(int argc, char * argv[] ) {
-   (void)argc;
-   (void)argv;
+int main() {
    using boost::tuples::set_close;
    using boost::tuples::set_open;
    using boost::tuples::set_delimiter;
@@ -138,6 +137,5 @@ int test_main(int argc, char * argv[] ) {
   // general. If this is wanted, some kind of a parseable string class
   // should be used.
   
-  return 0;
+  return boost::report_errors();
 }
-

test/std_tuple_element.cpp

@@ -0,0 +1,56 @@
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+BOOST_PRAGMA_MESSAGE("Skipping std::tuple_element tests for lack of <tuple>")
+int main() {}
+
+#else
+
+#include <tuple>
+
+template<class Tp, std::size_t I, class E> void test()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<typename std::tuple_element<I, Tp>::type, E>));
+
+    typedef typename Tp::inherited Tp2;
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<typename std::tuple_element<I, Tp2>::type, E>));
+}
+
+template<int> struct X
+{
+};
+
+int main()
+{
+    test<boost::tuple<X<0> const>, 0, X<0> const>();
+
+    test<boost::tuple<X<0> const, X<1> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const>, 1, X<1> const>();
+
+    test<boost::tuple<X<0> const, X<1> const, X<2> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const>, 1, X<1> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const>, 2, X<2> const>();
+
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 1, X<1> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 2, X<2> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const>, 3, X<3> const>();
+
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 0, X<0> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 1, X<1> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 2, X<2> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 3, X<3> const>();
+    test<boost::tuple<X<0> const, X<1> const, X<2> const, X<3> const, X<4> const>, 4, X<4> const>();
+
+    return boost::report_errors();
+}
+
+#endif

test/std_tuple_size.cpp

@@ -0,0 +1,61 @@
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE)
+
+BOOST_PRAGMA_MESSAGE("Skipping std::tuple_size tests for lack of <tuple>")
+int main() {}
+
+#else
+
+#include <tuple>
+
+template<class Tp> void test( std::size_t x )
+{
+    BOOST_TEST_EQ( std::tuple_size< Tp >::value, x );
+    BOOST_TEST_EQ( std::tuple_size< typename Tp::inherited >::value, x );
+}
+
+struct V
+{
+};
+
+int main()
+{
+    test< boost::tuple<> >( 0 );
+    test< boost::tuple<V> >( 1 );
+    test< boost::tuple<V, V> >( 2 );
+    test< boost::tuple<V, V, V> >( 3 );
+    test< boost::tuple<V, V, V, V> >( 4 );
+    test< boost::tuple<V, V, V, V, V> >( 5 );
+    test< boost::tuple<V, V, V, V, V, V> >( 6 );
+    test< boost::tuple<V, V, V, V, V, V, V> >( 7 );
+    test< boost::tuple<V, V, V, V, V, V, V, V> >( 8 );
+    test< boost::tuple<V, V, V, V, V, V, V, V, V> >( 9 );
+    test< boost::tuple<V, V, V, V, V, V, V, V, V, V> >( 10 );
+
+#if !defined(BOOST_NO_CXX11_DECLTYPE)
+
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple())>::value, 0 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1))>::value, 1 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2))>::value, 2 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3))>::value, 3 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4))>::value, 4 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5))>::value, 5 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6))>::value, 6 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7))>::value, 7 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8))>::value, 8 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8, 9))>::value, 9 );
+    BOOST_TEST_EQ( std::tuple_size<decltype(boost::make_tuple(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))>::value, 10 );
+
+#endif
+
+    return boost::report_errors();
+}
+
+#endif

test/structured_bindings.cpp

@@ -0,0 +1,77 @@
+// Copyright 2017 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX17_STRUCTURED_BINDINGS)
+
+BOOST_PRAGMA_MESSAGE("Skipping structured bindings test, not supported")
+int main() {}
+
+#else
+
+int main()
+{
+    // make_tuple
+
+    {
+        auto [x1] = boost::make_tuple( 1 );
+        BOOST_TEST_EQ( x1, 1 );
+    }
+
+    {
+        auto [x1, x2] = boost::make_tuple( 1, 2 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+    }
+
+    {
+        auto [x1, x2, x3] = boost::make_tuple( 1, 2, 3 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+    }
+
+    {
+        auto [x1, x2, x3, x4] = boost::make_tuple( 1, 2, 3, 4 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+        BOOST_TEST_EQ( x4, 4 );
+    }
+
+    // tuple
+
+    {
+        auto [x1] = boost::tuple<int>( 1 );
+        BOOST_TEST_EQ( x1, 1 );
+    }
+
+    {
+        auto [x1, x2] = boost::tuple<int, int>( 1, 2 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+    }
+
+    {
+        auto [x1, x2, x3] = boost::tuple<int, int, int>( 1, 2, 3 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+    }
+
+    {
+        auto [x1, x2, x3, x4] = boost::tuple<int, int, int, int>( 1, 2, 3, 4 );
+        BOOST_TEST_EQ( x1, 1 );
+        BOOST_TEST_EQ( x2, 2 );
+        BOOST_TEST_EQ( x3, 3 );
+        BOOST_TEST_EQ( x4, 4 );
+    }
+
+    return boost::report_errors();
+}
+
+#endif

test/tuple_test_bench.cpp

@@ -8,19 +8,18 @@
 
 //  tuple_test_bench.cpp  --------------------------------
 
-#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
-#include <boost/test/test_tools.hpp>    // see "Header Implementation Option"
-
 #include "boost/tuple/tuple.hpp"
-
 #include "boost/tuple/tuple_comparison.hpp"
 
 #include "boost/type_traits/is_const.hpp"
-
 #include "boost/ref.hpp"
+#include "boost/core/lightweight_test.hpp"
+
 #include <string>
 #include <utility>
 
+#define BOOST_CHECK BOOST_TEST
+
 using namespace boost;
 
 // ----------------------------------------------------------------------------
@@ -82,7 +81,7 @@ typedef tuple<std::string, std::pair<A, B> > t4;
 typedef tuple<A*, tuple<const A*, const B&, C>, bool, void*> t5;
 typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
 
-# if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
+# if !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x0551
 typedef tuple<B(A::*)(C&), A&> t7;
 #endif
 
@@ -307,7 +306,7 @@ make_tuple_test()
   
 // With function pointers, make_tuple works just fine
 
-#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551
+#if !defined(BOOST_BORLANDC) || BOOST_BORLANDC > 0x0551
    make_tuple(&make_tuple_test);
 #endif
       
@@ -472,7 +471,7 @@ void tuple_swap_test()
 // - main ---------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 
-int test_main(int, char *[]) {
+int main() {
 
   construction_test();
   element_access_test();
@@ -486,12 +485,6 @@ int test_main(int, char *[]) {
   const_tuple_test();
   tuple_length_test();
   tuple_swap_test();
-  return 0;
+
+  return boost::report_errors();
 }
-
-
-
-
-
-
-