feedc0de/boost_tuple
1
0
Fork 0
forked from boostorg/tuple
Code Pull Requests Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
djowel
2020-05-26 09:31:40 +08:00
parent 19f7cfdcdb cf820922ac
commit a4dff52f67
10 changed files with 287 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
include/boost/tuple/detail/tuple_basic.hpp
View File

@ -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 {

51
include/boost/tuple/tuple.hpp
View File

@ -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

4
include/boost/tuple/tuple_io.hpp
View File

@ -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

9
test/Jamfile
View File

@ -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 ]
;

9
test/another_tuple_test_bench.cpp
View File

@ -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();
}

14
test/io_test.cpp
View File

@ -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();
}

56
test/std_tuple_element.cpp Normal file
View File

@ -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

61
test/std_tuple_size.cpp Normal file
View File

@ -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

77
test/structured_bindings.cpp Normal file
View File

@ -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

25
test/tuple_test_bench.cpp
View File

@ -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();
}