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

More complete functionality for compilers without partial specialization.

Browse Source 
[SVN r19925]
This commit is contained in:
Dave Abrahams
2003-09-05 16:52:55 +00:00
parent eef0e01c8d
commit e4b869219b
3 changed files with 104 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
View File

@ -68,6 +68,10 @@ namespace tuples {
>
class tuple;
// forward declaration of cons
template<typename Head, typename Tail = null_type>
struct cons;
namespace detail {
// Takes a pointer and routes all assignments to whatever it points to
@ -99,10 +103,63 @@ namespace tuples {
};
template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
template <class MyTail>
struct init_tail
{
// Each of vc6 and vc7 seem to require a different formulation
// of this return type
template <class H, class T>
#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
static typename add_const<typename add_reference<T>::type>::type
#else
static typename add_const_reference<T>::type
#endif
execute( cons<H,T> const& u, long )
{
return u.get_tail();
}
};
template <>
struct init_tail<null_type>
{
template <class H>
static null_type execute( cons<H,null_type> const& u, long )
{
return null_type();
}
template <class U>
static null_type execute(U const&, ...)
{
return null_type();
}
private:
template <class H, class T>
void execute( cons<H,T> const&, int);
};
template <class Other>
Other const&
init_head( Other const& u, ... )
{
return u;
}
template <class H, class T>
typename add_reference<typename add_const<H>::type>::type
init_head( cons<H,T> const& u, int )
{
return u.get_head();
}
inline char**** init_head(null_type const&, int);
} // end of namespace detail
// cons builds a heterogenous list of types
template<typename Head, typename Tail = null_type>
template<typename Head, typename Tail>
struct cons
{
typedef cons self_type;
@ -123,15 +180,17 @@ namespace tuples {
head_cref get_head() const { return head; }
tail_cref get_tail() const { return tail; }
cons() : head(), tail() {}
#if defined BOOST_MSVC
template<typename Tail>
explicit cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
const Tail& t) : head(h), tail(t.head, t.tail)
{
}
explicit cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
const null_type& t) : head(h), tail(t)
{
}
@ -150,6 +209,12 @@ namespace tuples {
}
#endif
template <class U>
cons( const U& u )
: head(detail::init_head(u, 0))
, tail(detail::init_tail<Tail>::execute(u, 0L))
{
}
template<typename Other>
cons& operator=(const Other& other)
@ -437,23 +502,31 @@ namespace tuples {
typedef cons1 inherited;
typedef tuple self_type;
explicit tuple(t1_cref t1 = T1(),
t2_cref t2 = T2(),
t3_cref t3 = T3(),
t4_cref t4 = T4(),
t5_cref t5 = T5(),
t6_cref t6 = T6(),
t7_cref t7 = T7(),
t8_cref t8 = T8(),
t9_cref t9 = T9(),
t10_cref t10 = T10()
) :
tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
{}
tuple(
t1_cref t1,
t2_cref t2,
t3_cref t3 = T3(),
t4_cref t4 = T4(),
t5_cref t5 = T5(),
t6_cref t6 = T6(),
t7_cref t7 = T7(),
t8_cref t8 = T8(),
t9_cref t9 = T9(),
t10_cref t10 = T10()
) :
cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
{
}
explicit tuple(t1_cref t1)
: cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
{}
template<typename Head, typename Tail>
explicit tuple(const cons<Head, Tail>& other) :
tuple(const cons<Head, Tail>& other) :
cons1(other.head, other.tail)
{
}

3
test/another_tuple_test_bench.cpp
View File

@ -103,7 +103,6 @@ void foo2() {
void foo4()
{
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
double d = 2.7;
A a;
tuple<int, double&, const A&> t(1, d, a);
@ -119,8 +118,6 @@ void foo4()
#ifdef E10
dummy(get<5>(ct)); // illegal index
#endif
#endif
}
// testing copy and assignment with implicit conversions between elements

72
test/tuple_test_bench.cpp
View File

@ -22,6 +22,7 @@
#include "boost/type_traits/is_const.hpp"
#include "boost/ref.hpp"
#include <string>
#include <utility>
@ -81,7 +82,6 @@ public:
typedef tuple<int> t1;
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
typedef tuple<double&, const double&, const double, double*, const double*> t2;
typedef tuple<A, int(*)(char, int), C> t3;
typedef tuple<std::string, std::pair<A, B> > t4;
@ -92,22 +92,16 @@ typedef tuple<volatile int, const volatile char&, int(&)(float) > t6;
typedef tuple<B(A::*)(C&), A&> t7;
#endif
#endif
// -----------------------------------------------------------------------
// -tuple construction tests ---------------------------------------------
// -----------------------------------------------------------------------
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
no_copy y;
tuple<no_copy&> x = tuple<no_copy&>(y); // ok
#endif
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
char cs[10];
tuple<char(&)[10]> v2(cs); // ok
#endif
void
construction_test()
@ -162,12 +156,10 @@ construction_test()
// dummy(tuple<double&>()); // should fail, not defaults for references
// dummy(tuple<const double&>()); // likewise
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
double dd = 5;
dummy(tuple<double&>(dd)); // ok
dummy(tuple<const double&>(dd+3.14)); // ok, but dangerous
#endif
// dummy(tuple<double&>(dd+3.14)); // should fail,
// // temporary to non-const reference
@ -180,7 +172,6 @@ construction_test()
void element_access_test()
{
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
double d = 2.7;
A a;
tuple<int, double&, const A&, int> t(1, d, a, 2);
@ -211,45 +202,18 @@ void element_access_test()
++get<0>(t);
BOOST_TEST(get<0>(t) == 6);
using boost::tuples::element;
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, tuple<int, float> >::type>::value != true));
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<0, const tuple<int, float> >::type>::value));
#endif
BOOST_STATIC_ASSERT((boost::is_const<element<0, tuple<int, float> >::type>::value != true));
BOOST_STATIC_ASSERT((boost::is_const<element<0, const tuple<int, float> >::type>::value));
BOOST_STATIC_ASSERT((boost::is_const<element<1, tuple<int, float> >::type>::value != true));
BOOST_STATIC_ASSERT((boost::is_const<element<1, const tuple<int, float> >::type>::value));
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, tuple<int, float> >::type>::value != true));
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_STATIC_ASSERT((boost::is_const<boost::tuples::element<1, const tuple<int, float> >::type>::value));
#endif
dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
#else
double d = 2.7;
A a;
tuple<int, double, const A, int> t(1, d, a, 2);
int i = get<0>(t);
int i2 = get<3>(t);
BOOST_TEST(i == 1 && i2 == 2);
get<0>(t) = 5;
BOOST_TEST(t.head == 5);
// get<0>(ct) = 5; // can't assign to const
double e = get<1>(t);
BOOST_TEST(e > 2.69 && e < 2.71);
get<1>(t) = 3.14+i;
BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15);
// get<4>(t) = A(); // can't assign to const
// dummy(get<5>(ct)); // illegal index
++get<0>(t);
BOOST_TEST(get<0>(t) == 6);
dummy(i); dummy(i2); dummy(e); // avoid warns for unused variables
#endif
}
@ -320,31 +284,27 @@ make_tuple_test()
BOOST_TEST(get<1>(t2) == "Hi");
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
A a = A(); B b;
const A ca = a;
make_tuple(cref(a), b);
make_tuple(ref(a), b);
make_tuple(ref(a), cref(b));
make_tuple(boost::cref(a), b);
make_tuple(boost::ref(a), b);
make_tuple(boost::ref(a), boost::cref(b));
make_tuple(ref(ca));
#endif
make_tuple(boost::ref(ca));
// the result of make_tuple is assignable:
BOOST_TEST(make_tuple(2, 4, 6) ==
(make_tuple(1, 2, 3) = make_tuple(2, 4, 6)));
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
make_tuple("Donald", "Daisy"); // should work;
#endif
#endif
// std::make_pair("Doesn't","Work"); // fails
// You can store a reference to a function in a tuple
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
tuple<void(&)()> adf(make_tuple_test);
dummy(adf); // avoid warning for unused variable
#endif
// But make_tuple doesn't work
// with function references, since it creates a const qualified function type
@ -450,7 +410,6 @@ ordering_test()
// ----------------------------------------------------------------------------
void cons_test()
{
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
using tuples::cons;
using tuples::null_type;
@ -462,7 +421,6 @@ void cons_test()
cons<char, cons<int, cons<float, null_type> > > x;
dummy(x);
#endif
}
// ----------------------------------------------------------------------------