diff --git a/doc/design_decisions_rationale.html b/doc/design_decisions_rationale.html deleted file mode 100644 index 7c8ba68..0000000 --- a/doc/design_decisions_rationale.html +++ /dev/null @@ -1,132 +0,0 @@ - - -Design decisions rationale for Boost Tuple Library - - - -C++ Boost - -

Tuple Library : design decisions rationale

- -

About namespaces

- -

-There was a discussion about whether tuples should be in a separate namespace or directly at the boost namespace. -The common principle is that domain libraries (like graph, python) should be on a separate -sub-namespace, while utility like libraries directly in the boost namespace. -Tuples are somewhere in between, as the tuple template is clearly a general utility, but the library introduces quite a lot of names in addition to just the tuple template. -As a result of the discussion, tuple definitions are now directly under the boost namespace. -

- -

For those who are really interested in namespaces

- -

-Note! The following discussion is not relevant for the Tuple library, as the 'no -sub-namespace' decision was taken, but it may be useful for other library writers. -

-

-In the original tuple library submission, all names were under the namespace tuples. This brought up the issue of naming -sub-namespaces. -The rationale for not using the most natural name 'tuple' was to avoid having an identical name with the tuple template. Namespace names are, however, not generally in plural form in boost libraries. Further, no real trouble was reported for using the same name for a namespace and a class. -But we found some trouble after all. -One solution proposed to the dilemma of introducing a sub-namespace or not was as follows: use a -sub-namespace but lift the most common names to the boost namespace with using declarations. -Both gcc and edg compilers rejected such using declarations if the namespace and class names were identical: - -

namespace boost {
-  namespace tuple {
-    class cons;
-    class tuple; 
-      ...
-  }
-  using tuple::cons; // ok
-  using tuple::tuple; // error
-    ...
-}
-
- - -Note, however, that a corresponding using declaration in the global namespace seemed to be ok: - -
-using boost::tuple::tuple; // ok;
-
 - - -

The end mark of the cons list (nil, null_type, ...)

- -

-Tuples are internally represented as cons lists: - -

tuple<int, int>
-
-inherits from -
cons<int, cons<int, null_type> >
-
- -null_type is the end mark of the list. Original proposition was nil, but the name is used in MacOS, and might have caused problems, so null_type was chosen instead. -Other names considered were null_t and unit (the empty tuple type in SML). -

-Note that null_type is the internal representation of an empty tuple: tuple<> inherits from null_type. -

- -

Element indexing

- -

-Whether to use 0- or 1-based indexing was discussed more than thoroughly, and the following observations were made: - -

-Tuple access with the syntax get<N>(a), or a.get<N>() (where a is a tuple and N an index), was considered to be of the first category, hence, the index of the first element in a tuple is 0. - -

-A suggestion to provide 1-based 'name like' indexing with constants like _1st, _2nd, _3rd, ... was made. -By suitably chosen constant types, this would allow alternative syntaxes: - -

a.get<0>() == a.get(_1st) == a[_1st] == a(_1st);
-
- -We chose not to provide more than one indexing method for the following reasons: - - - -

Tuple comparison

- -The comparison operator implements lexicographical order. -Other orderings were considered, mainly dominance (a < b iff for each i a(i) < b(i)). -Our belief is, that lexicographical ordering, though not mathematically the most natural one, is the most frequently needed ordering in everyday programming. - -

Streaming

- -

-The characters specified with tuple stream manipulators are stored within the space allocated by ios_base::xalloc, which allocates storage for long type objects. -static_cast is used in casting between long and the stream's character type. -Streams that have character types not convertible back and forth to long thus fail to compile. - -This may be revisited at some point. The two possible solutions are: -

- -Back to the user's guide -

© Copyright Jaakko Järvi 2001. - - - diff --git a/doc/tuple_advanced_interface.html b/doc/tuple_advanced_interface.html deleted file mode 100644 index 7ebd675..0000000 --- a/doc/tuple_advanced_interface.html +++ /dev/null @@ -1,127 +0,0 @@ - - - - Tuple library advanced features - - -C++ Boost - - - - -

Tuple library advanced features

- - -

Metafunctions for tuple types

-

-Suppose T is a tuple type, and N is a constant integral expression. - -

tuple_element<N, T>::type
- -gives the type of the Nth element in the tuple type T. -

- -
tuple_length<T>::value
 - -gives the length of the tuple type T. -

- -

Cons lists

- -

-Tuples are internally represented as cons lists. -For example, the tuple - -

tuple<A, B, C, D>
- - inherits from the type -
cons<A, cons<B, cons<C, cons<D, null_type> > > >
-
 - -The tuple template provides the typedef inherited to access the cons list representation. E.g.: -tuple<A>::inherited is the type cons<A, null_type>. -

- -

Empty tuple

-

-The internal representation of the empty tuple tuple<> is null_type. -

- -

Head and tail

-

-Both tuple template and the cons templates provide the typedefs head_type and tail_type. -The head_type typedef gives the type of the first element of the tuple (or the cons list). -The -tail_type typedef gives the remaining cons list after removing the first element. -The head element is stored in the member variable head and the tail list in the member variable tail. -Cons lists provide the member function get_head() for getting a reference to the head of a cons list, and get_tail() for getting a reference to the tail. -There are const and non-const versions of both functions. -

-

-Note that in a one element tuple, tail_type equals null_type and the get_tail() function returns an object of type null_type. -

-

-The empty tuple (null_type) has no head or tail, hence the get_head and get_tail functions are not provided. -

- -

-Treating tuples as cons lists gives a convenient means to define generic functions to manipulate tuples. For example, the following pair of function templates assign 0 to each element of a tuple (obviously, the assignments must be valid operations for the element types): - -

inline void set_to_zero(const null_type&) {};
-
-template <class H, class T>
-inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
-
-

- -

Constructing cons lists

- -

-A cons list can be constructed from its head and tail. The prototype of the constructor is: -

cons(typename tuple_access_traits<head_type>::parameter_type h,
-     const tail_type& t)
-
-The traits template for the head parameter selects correct parameter types for different kinds of element types (for reference elements the parameter type equals the element type, for non-reference types the parameter type is a reference to const non-volatile element type). -

-

-For a one-element cons list the tail argument (null_type) can be omitted. -

- -

Traits classes for tuple element types

- -

tuple_access_traits

-

-The template tuple_access_traits defines three type functions. Let T be a type of an element in a tuple: -

    -
  1. tuple_access_traits<T>::type maps T to the return type of the non-const access functions (nonmeber and member get functions, and the get_head function).
    2. -
  2. tuple_access_traits<T>::const_type maps T to the return type of the const access functions.
    3. -
  3. tuple_access_traits<T>::parameter_type maps T to the parameter type of the tuple constructor.
    4. -
-

make_tuple_traits

- -The element types of the tuples that are created with the make_tuple functions are computed with the type function make_tuple_traits. -The type function call make_tuple_traits<T>::type implements the following type mapping: - - -Objects of type reference_wrapper are created with the ref and cref functions (see The make_tuple function.) -

- -

Note, that the reference_wrapper template and the ref and cref functions are defined in a separate hpp-file reference_wrappers.hpp, which can be included without including the rest of the tuple library. -

- -Back to the user's guide -
- -

© Copyright Jaakko Järvi 2001.

- - diff --git a/doc/tuple_users_guide.html b/doc/tuple_users_guide.html deleted file mode 100644 index 87f2983..0000000 --- a/doc/tuple_users_guide.html +++ /dev/null @@ -1,512 +0,0 @@ - - -The Boost Tuple Library - - - -C++ Boost - -

The Boost Tuple Library

- -

-A tuple (or n-tuple) is a fixed size collection of elements. -Pairs, triples, quadruples etc. are tuples. -In a programming language, a tuple is a data object containing other objects as elements. -These element objects may be of different types. -

- -

Tuples are convenient in many circumstances. -For instance, tuples make it easy to define functions that return more than one value. -

- -

-Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. -Unfortunately C++ does not. -To compensate for this "deficiency", the Boost Tuple Library implements a tuple construct using templates. -

- -

Table of Contents

- -
    -
  1. Using the library
    2. -
  2. Tuple types
    3. -
  3. Constructing tuples
    4. -
  4. Accessing tuple elements
    5. -
  5. Copy construction and tuple assignment
    6. -
  6. Relational operators
    7. -
  7. Tiers
    8. -
  8. Streaming
    9. -
  9. Performance
    10. -
  10. Portability
    11. -
  11. Acknowledgements
    12. -
  12. References
    13. -
- -

More details

- -

-Advanced features (describes some metafunctions etc.).

-

-Rationale behind some design/implementation decisions.

- - -

Using the library

- -

To use the library, just include: - -

#include "boost/tuple/tuple.hpp"
- -

Comparison operators can be included with: -

#include "boost/tuple/tuple_comparison.hpp"
- -

To use tuple input and output operators, - -

#include "boost/tuple/tuple_io.hpp"
-and add the libs/tuple/src/tuple.hpp file to your project. - -Both tuple_io.hpp and tuple_comparison.hpp include tuple.hpp. - -

All definitions are in namespace boost. - -

Tuple types

- -

A tuple type is an instantiation of the tuple template. -The template parameters specify the types of the tuple elements. -The current version supports tuples with 0-10 elements. -If necessary, the upper limit can be increased up to, say, a few dozen elements. -The data element can be any C++ type, except for a type that cannot be copied, e.g.: - -

-However, a reference to a non-copyable type is a valid element type. - -

-For example, the following definitions are valid tuple instantiations (A, B and C are some user defined classes): - -

tuple<int>
-tuple<double&, const double&, const double, double*, const double*>
-tuple<A, int(*)(char, int), B(A::*)(C&), C>
-tuple<std::string, std::pair<A, B> >
-tuple<A*, tuple<const A*, const B&, C>, bool, void*>
-
- -

-The following code shows some invalid tuple instantiations: -

class Y { 
-  Y(const Y&); 
-public:
-  Y();
-};
-
-tuple<Y>        // not allowed, objects of type Y cannot be copied
-tuple<char[10]> // not allowed: arrays cannot be copied
-
- -Note however that tuple<Y&> and tuple<char(&)[10]> are valid instantiations. - - -

Constructing tuples

- -

-The tuple constructor takes the tuple elements as arguments. -For an n-element tuple, the constructor can be invoked with k arguments, where 0 < k <= n. -For example: -

tuple<int, double>() 
-tuple<int, double>(1) 
-tuple<int, double>(1, 3.14)
-
- -

-If no initial value for an element is provided, it is default initialized (and hence must be default initializable). -For example. - -

class X {
-  X(); 
-public:
-  X(std::string);
-};
-
-tuple<X,X,X>()                                              // error: no default constructor for X
-tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok
-
- -In particular, reference types do not have a default initialization: - -
tuple<double&>()                // error: reference must be 
-                                // initialized explicitly
-
-double d = 5; 
-tuple<double&>(d)               // ok
-
-tuple<double&>(d+3.14)          // error: cannot initialize 
-                                // non-const reference with a temporary
-
-tuple<const double&>(d+3.14)    // ok, but dangerous: 
-                                // the element becomes a dangling reference 
-
- -

In sum, the tuple construction is semantically just a group of individual elementary constructions. -

- -

The make_tuple function

- -

-Tuples can also be constructed using the make_tuple (cf. std::make_pair) helper functions. -This makes the construction more convenient, saving the programmer from explicitly specifying the element types: -

tuple<int, int, double> add_multiply_divide(int a, int b) {
-  return make_tuple(a+b, a*b, double(a)/double(b));
-}
-
- -

-By default, the element types are deduced to the plain non-reference types. E.g: -

void foo(const A& a, B& b) { 
-  ...
-  make_tuple(a, b);
-
-The make_tuple invocation results in a tuple of type tuple<A, B>. - -

-Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied. -Therefore, the programmer can control the type deduction and state that a reference to const or reference to -non-const type should be used as the element type instead. -This is accomplished with two helper template functions: ref and cref. -Any argument can be wrapped with these functions to get the desired type. -The mechanism does not compromise const correctness since a const object wrapped with ref results in a tuple element with const reference type (see the fifth code line below). -For example: - -

A a; B b; const A ca = a;
-make_tuple(cref(a), b);      // creates tuple<const A&, B>
-make_tuple(ref(a), b);       // creates tuple<A&, B>
-make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>
-make_tuple(cref(ca));        // creates tuple<const A&>
-make_tuple(ref(ca));         // creates tuple<const A&>
-
- - -

-Array arguments to make_tuple functions are deduced to reference to const types by default; there is no need to wrap them with cref. For example: -

make_tuple("Donald", "Daisy");
-
- -This creates an object of type tuple<const char (&)[5], const char (&)[6]> -(note that the type of a string literal is an array of const characters, not const char*). -However, to get make_tuple to create a tuple with an element of a -non-const array type one must use the ref wrapper. - -

-Function pointers are deduced to the plain non-reference type, that is, to plain function pointer. -A tuple can also hold a reference to a function, -but such a tuple cannot be constructed with make_tuple (a const qualified function type would result, which is illegal): -

void f(int i);
-  ...
-make_tuple(&f); // tuple<void (*)(int)>
-  ...
-tuple<tuple<void (&)(int)> > a(f) // ok
-make_tuple(f);                    // not ok
-
- -

Accessing tuple elements

- -

-Tuple elements are accessed with the expression: - -

t.get<N>()
-
-or -
get<N>(t)
-
-where t is a tuple object and N is a constant integral expression specifying the index of the element to be accessed. -Depending on whether t is const or not, get returns the Nth element as a reference to const or -non-const type. -The index of the first element is 0 and thus -N must be between 0 and k-1, where k is the number of elements in the tuple. -Violations of these constrains are detected at compile time. Examples: - -
double d = 2.7; A a;
-tuple<int, double&, const A&> t(1, d, a);
-const tuple<int, double&, const A&> ct = t;
-  ...
-int i = get<0>(t); i = t.get<0>();        // ok
-int j = get<0>(ct);                       // ok
-get<0>(t) = 5;                            // ok 
-get<0>(ct) = 5;                           // error, can't assign to const 
-  ...
-double e = get<1>(t); // ok   
-get<1>(t) = 3.14;     // ok 
-get<2>(t) = A();      // error, can't assign to const 
-A aa = get<3>(t);     // error: index out of bounds 
-  ...
-++get<0>(t);  // ok, can be used as any variable
-
- -

Copy construction and tuple assignment

- -

-A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible. -Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable. -For example: - -

class A;
-class B : public A {};
-struct C { C(); C(const B&); }
-struct D { operator C() const; }
-tuple<char, B*, B, D> t;
-  ...
-tuple<int, A*, C, C> a(t); // ok 
-a = t;                     // ok 
-
- -In both cases, the conversions performed are: char -> int, B* -> A* (derived class pointer to base class pointer), B -> C (a user defined conversion) and D -> C (a user defined conversion). - -

-Note that assignment is also defined from std::pair types: - -

tuple<float, int> a = std::make_pair(1, 'a');
-
- -

Relational operators

-

-Tuples reduce the operators ==, !=, <, >, <= and >= to the corresponding elementary operators. -This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well. - -The equality operators for two tuples a and b are defined as: -

- -The operators <, >, <= and >= implement a lexicographical ordering. - -

-Note that an attempt to compare two tuples of different lengths results in a compile time error.

-Also, the comparison operators are "short-circuited": elementary comparisons start from the first elements and are performed only until the result is clear. - -

Examples: - -

tuple<std::string, int, A> t1(std::string("same?"), 2, A());
-tuple<std::string, long, A> t2(std::string("same?"), 2, A());
-tuple<std::string, long, A> t3(std::string("different"), 3, A());
-
-bool operator==(A, A) { std::cout << "All the same to me..."; return true; }
-
-t1 == t2; 		// true
-t1 == t3;               // false, does not print "All the..."
-
- - -

Tiers

- -

-Tiers are tuples, where all elements are of non-const reference types. -They are constructed with a call to the tie function template (cf. make_tuple): - -

int i; char c; double d; 
-  ...
-tie(i, c, a);
-
- -

-The above tie function creates a tuple of type tuple<int&, char&, double&>. -The same result could be achieved with the call make_tuple(ref(i), ref(c), ref(a)). -

- -

-A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.: - -

int i; char c; double d; 
-tie(i, c, d) = make_tuple(1,'a', 5.5);
-std::cout << i << " " <<  c << " " << d;
-
-This code prints 1 a 5.5 to the standard output stream. - -A tuple unpacking operation like this is found for example in ML and Python. -It is convenient when calling functions which return tuples. - -

-The tying mechanism works with std::pair templates as well: - -

int i; char c;
-tie(i, c) = std::make_pair(1, 'a');
-
-

Ignore

-There is also an object called ignore which allows you to ignore an element assigned by a tuple. -The idea is that a function may return a tuple, only part of which you are interested in. For example: - -
char c;
-tie(ignore, c) = std::make_pair(1, 'a');
-
- -

Streaming

- -

-The global operator<< has been overloaded for std::ostream such that tuples are -output by recursively calling operator<< for each element. -

- -

-Analogously, the global operator>> has been overloaded to extract tuples from std::istream by recursively calling operator>> for each element. -

- -

-The default delimiter between the elements is space, and the tuple is enclosed -in parenthesis. -For Example: - -

tuple<float, int, std::string> a(1.0f,  2, std::string("Howdy folks!");
-
-cout << a; 
-
-outputs the tuple as: (1.0 2 Howdy folks!) - -

-The library defines three manipulators for changing the default behavior: -

- -For example: -
cout << set_open('[') << set_close(']') << set_delimiter(',') << a; 
-
-outputs the same tuple a as: [1.0,2,Howdy folks!] - -

The same manipulators work with operator>> and istream as well. Suppose the cin stream contains the following data: - -

(1 2 3) [4:5]
- -The code: - -
tuple<int, int, int> i;
-tuple<int, int> j;
-
-cin >> i;
-cin >> set_open('[') >> set_close(']') >> set_delimiter(':');
-cin >> j;
-
- -reads the data into the tuples i and j. - -

-Note that extracting tuples with std::string or C-style string -elements does not generally work, since the streamed tuple representation may not be unambiguously -parseable. -

- -

Performance

- -Tuples are efficient. All functions are small inlined one-liners and a decent compiler will eliminate any extra cost. -Particularly, there is no performance difference between this code: - -
class hand_made_tuple { 
-  A a; B b; C c;
-public:
-  hand_made_tuple(const A& aa, const B& bb, const C& cc) 
-    : a(aa), b(bb), c(cc) {};
-  A& getA() { return a; };
-  B& getB() { return b; };
-  C& getC() { return c; };
-};
-
-hand_made_tuple hmt(A(), B(), C()); 
-hmt.getA(); hmt.getB(); hmt.getC();
-
- -and this code: - -
tuple<A, B, C> t(A(), B(), C());
-t.get<0>(); t.get<1>(); t.get<2>(); 
-
- -

-Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using -non-const reference parameters as a mechanism for returning multiple values from a function. -For example, suppose that the following functions f1 and f2 have equivalent functionalities: - -

void f1(int&, double&);
-tuple<int, double> f2();
-
- -Then, the call #1 may be slightly faster than #2 in the code below: - -
int i; double d;
-  ...
-f1(i,d);         // #1
-tie(i,d) = f2(); // #2
-
-See -[1, -2] - for more in-depth discussions about efficiency. - -

Effect on Compile Time

- -

-Compiling tuples can be slow due to the excessive amount of template instantiations. -Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the hand_made_tuple class above. -However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable. -Compile time increases between 5 to 10 percentages were measured for programs which used tuples very frequently. -With the same test programs, memory consumption of compiling increased between 22% to 27%. See -[1, -2] -for details. -

- -

Portability

- -

The library code is(?) standard C++ and thus the library works with a standard conforming compiler. -Below is a list of compilers and known problems with each compiler: -

- - - - - - - -
CompilerProblems
gcc 2.95-
edg 2.44-
Borland 5.5Can't use function pointers or member pointers as tuple elements
Metrowerks 6.2Can't use ref and cref wrappers
MS Visual C++No reference elements (tie still works). Can't use ref and cref wrappers
- -

Acknowledgements

-Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC. Thanks to Jeremy Siek, William Kempf, Jens Maurer for their help and suggestions. -The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes and David Abrahams helped to improve the -library. -The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs. - -

References

- -

-[1] -Järvi J.: Tuples and multiple return values in C++, TUCS Technical Report No 249, 1999 (http://www.tucs.fi/publications). -

- -

-[2] -Järvi J.: ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism, TUCS Technical Report No 267, 1999 (http://www.tucs.fi/publications). -

- -

-[3] Järvi J.:Tuple Types and Multiple Return Values, C/C++ Users Journal, August 2001. -

- -
- -

Last modified 2001-08-10

- -

© Copyright Jaakko Järvi 2001. - -Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. -This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose. -

- - - - - - diff --git a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp b/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp deleted file mode 100644 index fa197b1..0000000 --- a/include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp +++ /dev/null @@ -1,654 +0,0 @@ -// - tuple_basic_no_partial_spec.hpp ----------------------------------------- - -// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu) -// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) -// -// Permission to copy, use, sell and distribute this software is granted -// provided this copyright notice appears in all copies. -// Permission to modify the code and to distribute modified code is granted -// provided this copyright notice appears in all copies, and a notice -// that the code was modified is included with the copyright notice. -// -// This software is provided "as is" without express or implied warranty, -// and with no claim as to its suitability for any purpose. - -// For more information, see http://www.boost.org or http://lambda.cs.utu.fi - -// Revision History -// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG) -// 10 02 01 Fixed "null_type" constructors. -// Implemented comparison operators globally. -// Hide element_type_ref and element_type_const_ref. -// (DG). -// 09 02 01 Extended to tuples of length 10. Changed comparison for -// operator<() -// to the same used by std::pair<>, added cnull_type() (GP) -// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG) - -// ----------------------------------------------------------------- - -#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP -#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP - -#include "boost/type_traits.hpp" - -#if defined BOOST_MSVC -#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored -#pragma warning(disable:4181) // qualifier applied to reference type ignored -#pragma warning(disable:4227) // qualifier applied to reference type ignored -#endif - -namespace boost { - - // null_type denotes the end of a list built with "cons" - struct null_type - { - null_type() {} - null_type(const null_type&, const null_type&) {} - }; - - // a helper function to provide a const null_type type temporary - inline const null_type cnull_type() { return null_type(); } - - namespace detail { - namespace tuples { - // Takes a pointer and routes all assignments to whatever it points to - template - struct assign_to_pointee - { - public: - explicit assign_to_pointee(T* p) : ptr(p) {} - - template - assign_to_pointee& operator=(const Other& other) - { - *ptr = other; - return *this; - } - - private: - T* ptr; - }; - - // Swallows any assignment - struct swallow_assign - { - template - swallow_assign& operator=(const T&) - { - return *this; - } - }; - - } // end of namespace tuples - } // end of namespace detail - - // cons builds a heterogenous list of types - template - struct cons - { - typedef cons self_type; - typedef Head head_type; - typedef Tail tail_type; - - head_type head; - tail_type tail; - - typename boost::add_reference::type get_head() { return head; } - typename boost::add_reference::type get_tail() { return tail; } - - typename boost::add_reference::type get_head() const { return head; } - typename boost::add_reference::type get_tail() const { return tail; } - - template - explicit cons(const Other& other) : head(other.head), tail(other.tail) - { - } - -#if defined BOOST_MSVC - explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf. - const tail_type& t = tail_type()) : - head(h), tail(t) - { - } -#else - explicit cons(const head_type& h = head_type(), - const tail_type& t = tail_type()) : - head(h), tail(t) - { - } -#endif - - - template - cons& operator=(const Other& other) - { - head = other.head; - tail = other.tail; - return *this; - } - }; - - namespace detail { - namespace tuples { - // Determines if the parameter is null_type - template struct is_null_type { enum { RET = 0 }; }; - template<> struct is_null_type { enum { RET = 1 }; }; - - /* Build a cons structure from the given Head and Tail. If both are null_type, - return null_type. */ - template - struct build_cons - { - private: - enum { tail_is_null_type = is_null_type::RET }; - public: - typedef cons RET; - }; - - template<> - struct build_cons - { - typedef null_type RET; - }; - - // Map the N elements of a tuple into a cons list - template< - typename T1, - typename T2 = null_type, - typename T3 = null_type, - typename T4 = null_type, - typename T5 = null_type, - typename T6 = null_type, - typename T7 = null_type, - typename T8 = null_type, - typename T9 = null_type, - typename T10 = null_type - > - struct map_tuple_to_cons - { - typedef typename detail::tuples::build_cons::RET cons10; - typedef typename detail::tuples::build_cons::RET cons9; - typedef typename detail::tuples::build_cons::RET cons8; - typedef typename detail::tuples::build_cons::RET cons7; - typedef typename detail::tuples::build_cons::RET cons6; - typedef typename detail::tuples::build_cons::RET cons5; - typedef typename detail::tuples::build_cons::RET cons4; - typedef typename detail::tuples::build_cons::RET cons3; - typedef typename detail::tuples::build_cons::RET cons2; - typedef typename detail::tuples::build_cons::RET cons1; - }; - - // Workaround the lack of partial specialization in some compilers - template - struct _element_type - { - template - struct inner - { - private: - typedef typename Tuple::tail_type tail_type; - typedef _element_type next_elt_type; - - public: - typedef typename _element_type::template inner::RET RET; - }; - }; - - template<> - struct _element_type<0> - { - template - struct inner - { - typedef typename Tuple::head_type RET; - }; - }; - } // detail - } // tuples - - // Return the Nth type of the given Tuple - template - struct tuple_element - { - private: - typedef detail::tuples::_element_type nth_type; - - public: - typedef typename nth_type::template inner::RET RET; - typedef RET type; - }; - - namespace detail { - namespace tuples { - // Return a reference to the Nth type of the given Tuple - template - struct tuple_element_ref - { - private: - typedef typename tuple_element::RET elt_type; - - public: - typedef typename add_reference::type RET; - typedef RET type; - }; - - // Return a const reference to the Nth type of the given Tuple - template - struct tuple_element_const_ref - { - private: - typedef typename tuple_element::RET elt_type; - - public: - typedef typename add_reference::type RET; - typedef RET type; - }; - } - } - // Get length of this tuple - template - struct tuple_length - { - enum { value = 1 + tuple_length::value }; - }; - - template<> - struct tuple_length - { - enum { value = 0 }; - }; - - // Reference the Nth element in a tuple and retrieve it with "get" - template - struct element - { - template - static inline - typename detail::tuples::tuple_element_ref::RET - get(Tuple& t) - { - return element::get(t.tail); - } - - template - static inline - typename detail::tuples::tuple_element_const_ref::RET - get(const Tuple& t) - { - return element::get(t.tail); - } - }; - - template<> - struct element<0> - { - template - static inline - typename add_reference::type - get(Tuple& t) - { - return t.head; - } - - template - static inline - typename add_reference::type - get(const Tuple& t) - { - return t.head; - } - }; - - // tuple class - template< - typename T1, - typename T2 = null_type, - typename T3 = null_type, - typename T4 = null_type, - typename T5 = null_type, - typename T6 = null_type, - typename T7 = null_type, - typename T8 = null_type, - typename T9 = null_type, - typename T10 = null_type - > - class tuple : - public detail::tuples::map_tuple_to_cons::cons1 - { - private: - typedef detail::tuples::map_tuple_to_cons mapped_tuple; - typedef typename mapped_tuple::cons10 cons10; - typedef typename mapped_tuple::cons9 cons9; - typedef typename mapped_tuple::cons8 cons8; - typedef typename mapped_tuple::cons7 cons7; - typedef typename mapped_tuple::cons6 cons6; - typedef typename mapped_tuple::cons5 cons5; - typedef typename mapped_tuple::cons4 cons4; - typedef typename mapped_tuple::cons3 cons3; - typedef typename mapped_tuple::cons2 cons2; - typedef typename mapped_tuple::cons1 cons1; - - public: - typedef tuple self_type; - - explicit tuple(const T1& t1 = T1(), - const T2& t2 = T2(), - const T3& t3 = T3(), - const T4& t4 = T4(), - const T5& t5 = T5(), - const T6& t6 = T6(), - const T7& t7 = T7(), - const T8& t8 = T8(), - const T9& t9 = T9(), - const T10& t10 = T10()) : - cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10)))))))))) - { - } - - template - explicit tuple(const Other& other) : cons1(other) - { - } - - template - self_type& operator=(const Other& other) - { - this->head = other.head; - this->tail = other.tail; - return *this; - } - }; - - // Retrieve the Nth element in the typle - template - typename detail::tuples::tuple_element_ref::RET - get(Tuple& t) - { - return element::get(t); - } - - // Retrieve the Nth element in the typle - template - typename detail::tuples::tuple_element_const_ref::RET - get(const Tuple& t) - { - return element::get(t); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1) - { - return tuple(t1); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2) - { - return tuple(t1, t2); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3) - { - return tuple(t1, t2, t3); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) - { - return tuple(t1, t2, t3, t4); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) - { - return tuple(t1, t2, t3, t4, t5); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) - { - return tuple(t1, t2, t3, t4, t5, t6); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) - { - return tuple(t1, t2, t3, t4, t5, t6, t7); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) - { - return tuple(t1, t2, t3, t4, t5, t6, t7, t8); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) - { - return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9); - } - - // Make a tuple - template - inline - tuple - make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) - { - return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); - } - - // Tie variables into a tuple - template - inline - tuple > - tie(T1& t1) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4), - detail::tuples::assign_to_pointee(&t5)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4), - detail::tuples::assign_to_pointee(&t5), - detail::tuples::assign_to_pointee(&t6)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4), - detail::tuples::assign_to_pointee(&t5), - detail::tuples::assign_to_pointee(&t6), - detail::tuples::assign_to_pointee(&t7)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4), - detail::tuples::assign_to_pointee(&t5), - detail::tuples::assign_to_pointee(&t6), - detail::tuples::assign_to_pointee(&t7), - detail::tuples::assign_to_pointee(&t8)); - } - - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4), - detail::tuples::assign_to_pointee(&t5), - detail::tuples::assign_to_pointee(&t6), - detail::tuples::assign_to_pointee(&t7), - detail::tuples::assign_to_pointee(&t8), - detail::tuples::assign_to_pointee(&t9)); - } - // Tie variables into a tuple - template - inline - tuple, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee, - detail::tuples::assign_to_pointee > - tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10) - { - return make_tuple(detail::tuples::assign_to_pointee(&t1), - detail::tuples::assign_to_pointee(&t2), - detail::tuples::assign_to_pointee(&t3), - detail::tuples::assign_to_pointee(&t4), - detail::tuples::assign_to_pointee(&t5), - detail::tuples::assign_to_pointee(&t6), - detail::tuples::assign_to_pointee(&t7), - detail::tuples::assign_to_pointee(&t8), - detail::tuples::assign_to_pointee(&t9), - detail::tuples::assign_to_pointee(&t10)); - } - // "ignore" allows tuple positions to be ignored when using "tie". - namespace { - detail::tuples::swallow_assign ignore; - } - -} // namespace boost -#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP diff --git a/include/boost/tuple/reference_wrappers.hpp b/include/boost/tuple/reference_wrappers.hpp deleted file mode 100644 index 52df59f..0000000 --- a/include/boost/tuple/reference_wrappers.hpp +++ /dev/null @@ -1,57 +0,0 @@ -// -- reference_wrappers - Boost Tuple Library ----------------------------- - -// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) -// -// Permission to copy, use, sell and distribute this software is granted -// provided this copyright notice appears in all copies. -// Permission to modify the code and to distribute modified code is granted -// provided this copyright notice appears in all copies, and a notice -// that the code was modified is included with the copyright notice. -// -// This software is provided "as is" without express or implied warranty, -// and with no claim as to its suitability for any purpose. -// -// For more information, see http://www.boost.org - -// ----------------------------------------------------------------- - -#ifndef BOOST_TUPLE_REFERENCE_WRAPPERS_HPP -#define BOOST_TUPLE_REFERENCE_WRAPPERS_HPP - -namespace boost { - - -// reference wrappers ------------------------------------------------------- - -// These wrappers are handle classes that hold references to objects. - -// reference_wrapper is used to specify that a tuple element should be -// a reference to the wrapped object - rather than a copy of it. -// The wrapper acts as a disguise for passing non-const reference -// parameters via a reference to const parameter. - -template -class reference_wrapper { - T& x; -public: - explicit - reference_wrapper(T& t) : x(t) {} - operator T&() const { return x; } -}; - -// store as a reference to T -template -inline const reference_wrapper ref(T& t) { - return reference_wrapper(t); -} - -// store as a reference to const T -template -inline const reference_wrapper cref(const T& t) { - return reference_wrapper(t); -} - -} // end of namespace boost - - -#endif // BOOST_TUPLE_REFERENCE_WRAPPERS_HPP diff --git a/include/boost/tuple/tuple.hpp b/include/boost/tuple/tuple.hpp deleted file mode 100644 index bd39730..0000000 --- a/include/boost/tuple/tuple.hpp +++ /dev/null @@ -1,36 +0,0 @@ -// tuple.hpp - Boost Tuple Library -------------------------------------- - -// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) -// -// Permission to copy, use, sell and distribute this software is granted -// provided this copyright notice appears in all copies. -// Permission to modify the code and to distribute modified code is granted -// provided this copyright notice appears in all copies, and a notice -// that the code was modified is included with the copyright notice. -// -// This software is provided "as is" without express or implied warranty, -// and with no claim as to its suitability for any purpose. - -// For more information, see http://www.boost.org - -// ----------------------------------------------------------------- - -#ifndef BOOST_TUPLE_HPP -#define BOOST_TUPLE_HPP - -#include "boost/config.hpp" -#include "boost/static_assert.hpp" - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -// The MSVC version -#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp" - -#else -// other compilers -#include "boost/tuple/reference_wrappers.hpp" -#include "boost/tuple/detail/tuple_basic.hpp" - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - -#endif // BOOST_TUPLE_HPP diff --git a/include/boost/tuple/tuple_comparison.hpp b/include/boost/tuple/tuple_comparison.hpp deleted file mode 100644 index a34d67d..0000000 --- a/include/boost/tuple/tuple_comparison.hpp +++ /dev/null @@ -1,180 +0,0 @@ -// tuple_comparison.hpp ----------------------------------------------------- -// -// Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) -// -// Permission to copy, use, sell and distribute this software is granted -// provided this copyright notice appears in all copies. -// Permission to modify the code and to distribute modified code is granted -// provided this copyright notice appears in all copies, and a notice -// that the code was modified is included with the copyright notice. -// -// This software is provided "as is" without express or implied warranty, -// and with no claim as to its suitability for any purpose. -// -// For more information, see http://www.boost.org -// -// (The idea and first impl. of comparison operators was from Doug Gregor) - -// ----------------------------------------------------------------- - -#ifndef BOOST_TUPLE_COMPARISON_HPP -#define BOOST_TUPLE_COMPARISON_HPP - -#include "boost/tuple/tuple.hpp" - -// ------------------------------------------------------------- -// equality and comparison operators -// -// == and != compare tuples elementwise -// <, >, <= and >= use lexicographical ordering -// -// Any operator between tuples of different length fails at compile time -// No dependencies between operators are assumed -// (i.e. !(a=b, a!=b does not imply a==b etc. -// so any weirdnesses of elementary operators are respected). -// -// ------------------------------------------------------------- - - -namespace boost { - -inline bool operator==(const null_type&, const null_type&) { return true; } -inline bool operator>=(const null_type&, const null_type&) { return true; } -inline bool operator<=(const null_type&, const null_type&) { return true; } -inline bool operator!=(const null_type&, const null_type&) { return false; } -inline bool operator<(const null_type&, const null_type&) { return false; } -inline bool operator>(const null_type&, const null_type&) { return false; } - - -namespace detail { -namespace tuples { - // comparison operators check statically the length of its operands and - // delegate the comparing task to the following functions. Hence - // the static check is only made once (should help the compiler). - // These functions assume tuples to be of the same length. - - -template -inline bool eq(const T1& lhs, const T2& rhs) { - return lhs.get_head() == rhs.get_head() && - eq(lhs.get_tail(), rhs.get_tail()); -} -template<> -inline bool eq(const null_type&, const null_type&) { return true; } - -template -inline bool neq(const T1& lhs, const T2& rhs) { - return lhs.get_head() != rhs.get_head() || - neq(lhs.get_tail(), rhs.get_tail()); -} -template<> -inline bool neq(const null_type&, const null_type&) { return true; } - -template -inline bool lt(const T1& lhs, const T2& rhs) { - return lhs.get_head() < rhs.get_head() || - !(rhs.get_head() < lhs.get_head()) && - lt(lhs.get_tail(), rhs.get_tail()); -} -template<> -inline bool lt(const null_type&, const null_type&) { return false; } - -template -inline bool gt(const T1& lhs, const T2& rhs) { - return lhs.get_head() > rhs.get_head() || - !(rhs.get_head() > lhs.get_head()) && - gt(lhs.get_tail(), rhs.get_tail()); -} -template<> -inline bool gt(const null_type&, const null_type&) { return false; } - -template -inline bool lte(const T1& lhs, const T2& rhs) { - return lhs.get_head() <= rhs.get_head() && - ( !(rhs.get_head() <= lhs.get_head()) || - lte(lhs.get_tail(), rhs.get_tail())); -} -template<> -inline bool lte(const null_type&, const null_type&) { return true; } - -template -inline bool gte(const T1& lhs, const T2& rhs) { - return lhs.get_head() >= rhs.get_head() && - ( !(rhs.get_head() >= lhs.get_head()) || - gte(lhs.get_tail(), rhs.get_tail())); -} -template<> -inline bool gte(const null_type&, const null_type&) { return true; } - -} // end of namespace tuples -} // end of namespace detail - - -// equal ---- - -template -inline bool operator==(const cons& lhs, const cons& rhs) -{ - // check that tuple_lengths are equal - BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); - - return detail::tuples::eq(lhs, rhs); -} - -// not equal ----- - -template -inline bool operator!=(const cons& lhs, const cons& rhs) -{ - - // check that tuple_lengths are equal - BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); - - return detail::tuples::neq(lhs, rhs); -} - -// < -template -inline bool operator<(const cons& lhs, const cons& rhs) -{ - // check that tuple_lengths are equal - BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); - - return detail::tuples::lt(lhs, rhs); -} - -// > -template -inline bool operator>(const cons& lhs, const cons& rhs) -{ - // check that tuple_lengths are equal - BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); - - return detail::tuples::gt(lhs, rhs); -} - -// <= -template -inline bool operator<=(const cons& lhs, const cons& rhs) -{ - // check that tuple_lengths are equal - BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); - - return detail::tuples::lte(lhs, rhs); -} - -// >= -template -inline bool operator>=(const cons& lhs, const cons& rhs) -{ - // check that tuple_lengths are equal - BOOST_STATIC_ASSERT(tuple_length::value == tuple_length::value); - - return detail::tuples::gte(lhs, rhs); -} - -} // end of namespace boost - - -#endif // BOOST_TUPLE_COMPARISON_HPP diff --git a/include/boost/tuple/tuple_io.hpp b/include/boost/tuple/tuple_io.hpp deleted file mode 100644 index 3e8896f..0000000 --- a/include/boost/tuple/tuple_io.hpp +++ /dev/null @@ -1,501 +0,0 @@ -// tuple_io.hpp -------------------------------------------------------------- - -// Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) -// 2001 Gary Powell (gary.powell@sierra.com) -// -// Permission to copy, use, sell and distribute this software is granted -// provided this copyright notice appears in all copies. -// Permission to modify the code and to distribute modified code is granted -// provided this copyright notice appears in all copies, and a notice -// that the code was modified is included with the copyright notice. -// -// This software is provided "as is" without express or implied warranty, -// and with no claim as to its suitability for any purpose. -// For more information, see http://www.boost.org - -// ---------------------------------------------------------------------------- - -#ifndef BOOST_TUPLE_IO_HPP -#define BOOST_TUPLE_IO_HPP - - -// add to boost/config.hpp -// for now -# if defined __GNUC__ -# if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) -#define BOOST_NO_TEMPLATED_STREAMS -#endif -#endif // __GNUC__ - -#if defined BOOST_NO_TEMPLATED_STREAMS -#include -#else -#include -#include -#endif - -#include "boost/tuple/tuple.hpp" - - - -namespace boost { - -namespace detail { -namespace tuples { - -class format_info { -public: - enum manipulator_type { open, close, delimiter }; - BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1); -private: - - static const int stream_index[number_of_manipulators]; - format_info(const format_info&); - format_info(); - - -public: - -#if defined (BOOST_NO_TEMPLATED_STREAMS) - static char get_manipulator(std::ios& i, manipulator_type m) { - char c = static_cast(i.iword(stream_index[m])); - - // parentheses and space are the default manipulators - if (!c) { - switch(m) { - case open : c = '('; break; - case close : c = ')'; break; - case delimiter : c = ' '; break; - } - } - return c; - } - - static void set_manipulator(std::ios& i, manipulator_type m, char c) { - i.iword(stream_index[m]) = static_cast(c); - } -#else - template - static CharType get_manipulator(std::basic_ios& i, - manipulator_type m) { - // The manipulators are stored as long. - // A valid instanitation of basic_stream allows CharType to be any POD, - // hence, the static_cast may fail (it fails if long is not convertible - // to CharType - CharType c = static_cast(i.iword(stream_index[m]) ); - // parentheses and space are the default manipulators - if (!c) { - switch(m) { - case open : c = i.widen('('); break; - case close : c = i.widen(')'); break; - case delimiter : c = i.widen(' '); break; - } - } - return c; - } - - - template - static void set_manipulator(std::basic_ios& i, - manipulator_type m, CharType c) { - // The manipulators are stored as long. - // A valid instanitation of basic_stream allows CharType to be any POD, - // hence, the static_cast may fail (it fails if CharType is not - // convertible long. - i.iword(stream_index[m]) = static_cast(c); - } -#endif // BOOST_NO_TEMPLATED_STREAMS -}; - -template -class tuple_manipulator { - const format_info::manipulator_type mt; - CharType f_c; -public: - explicit tuple_manipulator(format_info::manipulator_type m, const char c = 0) - : mt(m), f_c(c) {} - -#if defined (BOOST_NO_TEMPLATED_STREAMS) - void set(std::ios &io) const { - format_info::set_manipulator(io, mt, f_c); - } -#else -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - template - void set(std::basic_ios &io) const { - format_info::set_manipulator(io, mt, f_c); - } -#else - template - void set(std::basic_ios &io) const { - format_info::set_manipulator(io, mt, f_c); - } -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -#endif // BOOST_NO_TEMPLATED_STREAMS -}; - -} // end of namespace tuples -} // end of namespace detail - - -#if defined (BOOST_NO_TEMPLATED_STREAMS) -inline std::ostream& -operator<<(std::ostream& o, const detail::tuples::tuple_manipulator& m) { - m.set(o); - return o; -} - -inline std::istream& -operator>>(std::istream& i, const detail::tuples::tuple_manipulator& m) { - m.set(i); - return i; -} - -#else - -template -inline std::basic_ostream& -operator<<(std::basic_ostream& o, const detail::tuples::tuple_manipulator& m) { - m.set(o); - return o; -} - -template -inline std::basic_istream& -operator>>(std::basic_istream& i, const detail::tuples::tuple_manipulator& m) { - m.set(i); - return i; -} - -#endif // BOOST_NO_TEMPLATED_STREAMS - -template -inline detail::tuples::tuple_manipulator set_open(const CharType c) { - return detail::tuples::tuple_manipulator(detail::tuples::format_info::open, c); -} - -template -inline detail::tuples::tuple_manipulator set_close(const CharType c) { - return detail::tuples::tuple_manipulator(detail::tuples::format_info::close, c); -} - -template -inline detail::tuples::tuple_manipulator set_delimiter(const CharType c) { - return detail::tuples::tuple_manipulator(detail::tuples::format_info::delimiter, c); -} - - - - - -// ------------------------------------------------------------- -// printing tuples to ostream in format (a b c) -// parentheses and space are defaults, but can be overriden with manipulators -// set_open, set_close and set_delimiter - -namespace detail { -namespace tuples { - -// Note: The order of the print functions is critical -// to let a conforming compiler find and select the correct one. - -#if defined (BOOST_NO_TEMPLATED_STREAMS) - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -template -inline std::ostream& print(std::ostream& o, const cons& t) { - return o << t.head; -} -#endif // BOOST_NO_TEMPLATED_STREAMS - -inline std::ostream& print(std::ostream& o, const null_type&) { return o; } - -template -inline std::ostream& -print(std::ostream& o, const cons& t) { - - const char d = format_info::get_manipulator(o, format_info::delimiter); - - o << t.head; - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuple_length::value == 0) - return o; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - o << d; - - return print(o, t.tail ); - -} - - - -#else - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -template -inline std::basic_ostream& -print(std::basic_ostream& o, const cons& t) { - return o << t.head; -} -#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - -template -inline std::basic_ostream& -print(std::basic_ostream& o, const null_type&) { - return o; -} - -template -inline std::basic_ostream& -print(std::basic_ostream& o, const cons& t) { - - const CharType d = format_info::get_manipulator(o, format_info::delimiter); - - o << t.head; - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuple_length::value == 0) - return o; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - o << d; - - return print(o, t.tail); -} - -#endif // BOOST_NO_TEMPLATED_STREAMS - -} // namespace tuples -} // namespace detail - -#if defined (BOOST_NO_TEMPLATED_STREAMS) -template -inline std::ostream& operator<<(std::ostream& o, const cons& t) { - if (!o.good() ) return o; - - const char l = - detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open); - const char r = - detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close); - - o << l; - - detail::tuples::print(o, t); - - o << r; - - return o; -} - -#else - -template -inline std::basic_ostream& -operator<<(std::basic_ostream& o, - const cons& t) { - if (!o.good() ) return o; - - const CharType l = - detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::open); - const CharType r = - detail::tuples::format_info::get_manipulator(o, detail::tuples::format_info::close); - - o << l; - - detail::tuples::print(o, t); - - o << r; - - return o; -} -#endif // BOOST_NO_TEMPLATED_STREAMS - - -// ------------------------------------------------------------- -// input stream operators - -namespace detail { -namespace tuples { - -#if defined (BOOST_NO_TEMPLATED_STREAMS) - -inline std::istream& -extract_and_check_delimiter( - std::istream& is, format_info::manipulator_type del) -{ - const char d = format_info::get_manipulator(is, del); - - const bool is_delimiter = (!isspace(d) ); - - char c; - if (is_delimiter) { - is >> c; - if (c!=d) { - is.setstate(std::ios::failbit); - } - } - return is; -} - - -// Note: The order of the read functions is critical to let a -// (conforming?) compiler find and select the correct one. - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -template -inline std::istream & -read (std::istream &is, cons& t1) { - - if (!is.good()) return is; - - return is >> t1.head ; -} -#else -inline std::istream& read(std::istream& i, const null_type&) { return i; } -#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -template -inline std::istream& -read(std::istream &is, cons& t1) { - - if (!is.good()) return is; - - is >> t1.head; - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuple_length::value == 0) - return is; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - extract_and_check_delimiter(is, format_info::delimiter); - - return read(is, t1.tail); -} - -} // end namespace tuples -} // end namespace detail - -inline std::istream& -operator>>(std::istream &is, null_type&) { - - if (!is.good() ) return is; - - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); - - return is; -} - - -template -inline std::istream& -operator>>(std::istream& is, cons& t1) { - - if (!is.good() ) return is; - - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); - - detail::tuples::read(is, t1); - - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); - - return is; -} - - - -#else - -template -inline std::basic_istream& -extract_and_check_delimiter( - std::basic_istream &is, format_info::manipulator_type del) -{ - const CharType d = format_info::get_manipulator(is, del); - - const bool is_delimiter = (!isspace(d) ); - - CharType c; - if (is_delimiter) { - is >> c; - if (c!=d) { - is.setstate(std::ios::failbit); - } - } - return is; -} - - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -template -inline std::basic_istream & -read (std::basic_istream &is, cons& t1) { - - if (!is.good()) return is; - - return is >> t1.head; -} -#else -template -inline std::basic_istream& -read(std::basic_istream& i, const null_type&) { return i; } - -#endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - -template -inline std::basic_istream& -read(std::basic_istream &is, cons& t1) { - - if (!is.good()) return is; - - is >> t1.head; - -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - if (tuple_length::value == 0) - return is; -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - extract_and_check_delimiter(is, format_info::delimiter); - - return read(is, t1.tail); -} - -} // end namespace tuples -} // end namespace detail - - -template -inline std::basic_istream& -operator>>(std::basic_istream &is, null_type&) { - - if (!is.good() ) return is; - - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); - - return is; -} - -template -inline std::basic_istream& -operator>>(std::basic_istream& is, cons& t1) { - - if (!is.good() ) return is; - - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::open); - - detail::tuples::read(is, t1); - - detail::tuples::extract_and_check_delimiter(is, detail::tuples::format_info::close); - - return is; -} - -#endif // BOOST_NO_TEMPLATED_STREAMS - -} // end of namespace boost - -#endif // BOOST_TUPLE_IO_HPP - - diff --git a/src/tuple.cpp b/src/tuple.cpp deleted file mode 100644 index 94f0ccc..0000000 --- a/src/tuple.cpp +++ /dev/null @@ -1,33 +0,0 @@ -// tuple.cpp ----------------------------------------------------- - -// Copyright (C) 1999, 2000, 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) -// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) -// -// Permission to copy, use, sell and distribute this software is granted -// provided this copyright notice appears in all copies. -// Permission to modify the code and to distribute modified code is granted -// provided this copyright notice appears in all copies, and a notice -// that the code was modified is included with the copyright notice. -// -// This software is provided "as is" without express or implied warranty, -// and with no claim as to its suitability for any purpose. - -// For more information, see http://lambda.cs.utu.fi - -// Revision History - -// 16 02 01 Initial Version (GWP) -// ----------------------------------------------------------------- - -#include "boost/tuple/tuple_io.hpp" - -namespace boost { -namespace detail { -namespace tuples { -const int - format_info::stream_index[number_of_manipulators] - = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() }; - -} // namespace tuples -} // namespace detail -} // namespace boost diff --git a/test/README b/test/README deleted file mode 100644 index 7a5c441..0000000 --- a/test/README +++ /dev/null @@ -1,14 +0,0 @@ -To compile the - -libs/tuple/test/*.cpp - -files, you need to set include paths -for boost. -For example, in libs/tuple/test directory you would type (using g++): - -g++ -I../../.. tuple_test_bench.cpp - -If you want to use tuple_io, you need to compile and link src/tuple.cpp: - -g++ -I../../.. ../src/tuple.cpp io_test.cpp - diff --git a/test/another_tuple_test_bench.cpp b/test/another_tuple_test_bench.cpp deleted file mode 100644 index 0f58ddf..0000000 --- a/test/another_tuple_test_bench.cpp +++ /dev/null @@ -1,163 +0,0 @@ -// tuple_test_bench.cpp -------------------------------- -// -// 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 // see "Header Implementation Option" - -#include "boost/tuple/tuple.hpp" - -#include "boost/tuple/tuple_comparison.hpp" - -using namespace std; -using namespace boost; - -class foo -{ -public: - explicit foo(int v) : val(v) {} - - bool operator==(const foo& other) const - { - return val == other.val; - } - -private: - foo() {} - int val; -}; - -void -construction_test() -{ - tuple t1; - BOOST_TEST(get<0>(t1) == int()); - - tuple t2(5.5f); - BOOST_TEST(get<0>(t2) == 5.5f); - - tuple t3(foo(12)); - BOOST_TEST(get<0>(t3) == foo(12)); - - tuple t4(t2); - BOOST_TEST(get<0>(t4) == 5.5); - - tuple t5; - BOOST_TEST(get<0>(t5) == int()); - BOOST_TEST(get<1>(t5) == float()); - - tuple t6(12, 5.5f); - BOOST_TEST(get<0>(t6) == 12); - BOOST_TEST(get<1>(t6) == 5.5f); - - tuple t7(t6); - BOOST_TEST(get<0>(t7) == 12); - BOOST_TEST(get<1>(t7) == 5.5f); -} - -void -copy_test() -{ - tuple t1(4, 12.5f); - tuple t2(5, 2.2f); - t2 = t1; - BOOST_TEST(get<0>(t1) == get<0>(t2)); - BOOST_TEST(get<1>(t1) == get<1>(t2)); - - tuple t3(2, 3.3); - t3 = t1; - BOOST_TEST((double)get<0>(t1) == get<0>(t3)); - BOOST_TEST((double)get<1>(t1) == get<1>(t3)); -} - -void -mutate_test() -{ - tuple t1(5, 12.2f, true, foo(4)); - get<0>(t1) = 6; - get<1>(t1) = 2.2f; - get<2>(t1) = false; - get<3>(t1) = foo(5); - - BOOST_TEST(get<0>(t1) == 6); - BOOST_TEST(get<1>(t1) == 2.2f); - BOOST_TEST(get<2>(t1) == false); - BOOST_TEST(get<3>(t1) == foo(5)); -} - -void -make_tuple_test() -{ - tuple t1 = make_tuple(5, 2.25f); - BOOST_TEST(get<0>(t1) == 5); - BOOST_TEST(get<1>(t1) == 2.25f); - - tuple t2; - t2 = make_tuple((short int)2, 2.25); - BOOST_TEST(get<0>(t2) == 2); - BOOST_TEST(get<1>(t2) == 2.25); -} - -void -tie_test() -{ - int a; - float b; - foo c(5); - - tie(a, b, c) = make_tuple(2, 5.5f, foo(3)); - BOOST_TEST(a == 2); - BOOST_TEST(b == 5.5f); - BOOST_TEST(c == foo(3)); - - tie(a, ignore, c) = make_tuple((short int)5, false, foo(5)); - BOOST_TEST(a == 5); - BOOST_TEST(b == 5.5f); - BOOST_TEST(c == foo(5)); -} - -void -equality_test() -{ - tuple t1(5, 3.3f); - tuple t2(5, 3.3f); - BOOST_TEST(t1 == t2); - - tuple t3(5, 2.2f); - tuple t4(2, 3.3f); - BOOST_TEST(t1 != t3); - BOOST_TEST(t1 != t4); -} - -void -ordering_test() -{ - tuple t1(4, 3.3f); - tuple t2(5, 3.3f); - tuple t3(5, 4.4); - BOOST_TEST(t1 < t2); - BOOST_TEST(t1 <= t2); - BOOST_TEST(t2 > t1); - BOOST_TEST(t2 >= t1); - BOOST_TEST(t2 < t3); - BOOST_TEST(t2 <= t3); - BOOST_TEST(t3 > t2); - BOOST_TEST(t3 >= t2); - -} - - -int -test_main(int, char *[]) -{ - construction_test(); - copy_test(); - mutate_test(); - make_tuple_test(); - tie_test(); - equality_test(); - ordering_test(); - - return 0; -} diff --git a/test/io_test.cpp b/test/io_test.cpp deleted file mode 100644 index ac6c2c8..0000000 --- a/test/io_test.cpp +++ /dev/null @@ -1,104 +0,0 @@ -// -- io_test.cpp ----------------------------------------------- -// -// 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 -#include -#include -#include - -#if defined BOOST_NO_STRINGSTREAM -#include -#else -#include -#endif - -#include "boost/config.hpp" - -using namespace std; -using namespace boost; - -#if defined BOOST_NO_STRINGSTREAM -typedef ostrstream useThisOStringStream; -typedef istrstream useThisIStringStream; -#else -typedef ostringstream useThisOStringStream; -typedef istringstream useThisIStringStream; -#endif - -int test_main(int argc, char * argv[] ) { - - useThisOStringStream os1; - - // Set format [a, b, c] for os1 - os1 << set_open('['); - os1 << set_close(']'); - os1 << set_delimiter(','); - os1 << make_tuple(1, 2, 3); - BOOST_TEST (os1.str() == std::string("[1,2,3]") ); - - { - useThisOStringStream os2; - // Set format (a:b:c) for os2; - os2 << set_open('('); - os2 << set_close(')'); - os2 << set_delimiter(':'); -#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5); - BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") ); -#endif - } - - // The format is still [a, b, c] for os1 - os1 << make_tuple(1, 2, 3); - BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") ); - - ofstream tmp("temp.tmp"); - -#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - tmp << make_tuple("One", "Two", 3); -#endif - tmp << set_delimiter(':'); - tmp << make_tuple(1000, 2000, 3000) << endl; - - tmp.close(); - - // When teading tuples from a stream, manipulators must be set correctly: - ifstream tmp3("temp.tmp"); - tuple j; - -#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - tmp3 >> j; - BOOST_TEST (tmp3.good() ); -#endif - - tmp3 >> set_delimiter(':'); - tuple i; - tmp3 >> i; - BOOST_TEST (tmp3.good() ); - - tmp3.close(); - - - // reading tuple in format (a b c); - useThisIStringStream is("(100 200 300)"); - - tuple ti; - BOOST_TEST(is >> ti); - BOOST_TEST(ti == make_tuple(100, 200, 300)); - - - // Note that strings are problematic: - // writing a tuple on a stream and reading it back doesn't work in - // general. If this is wanted, some kind of a parseable string class - // should be used. - - return 0; -} - diff --git a/test/tuple_test_bench.cpp b/test/tuple_test_bench.cpp deleted file mode 100644 index 87c3f28..0000000 --- a/test/tuple_test_bench.cpp +++ /dev/null @@ -1,289 +0,0 @@ -// tuple_test_bench.cpp -------------------------------- - -// 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 // see "Header Implementation Option" - -#include "boost/tuple/tuple.hpp" - -#include "boost/tuple/tuple_comparison.hpp" - -#include -#include -#include -#include -#include -#include - -using namespace std; -using namespace boost; - - - -template void dummy(const T&) {} - -class A {}; class B {}; class C {}; - -typedef int(t)(float); - -// some arbitrary tuple definitions -typedef tuple t1; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -typedef tuple t2; -typedef tuple t3; -typedef tuple > t4; -typedef tuple, bool, void*> t5; -typedef tuple t6; - -# if !defined(__BORLANDC__) || __BORLAND__ > 0x0551 -typedef tuple t7; -#endif - -#endif - -// A non-copyable class -class no_copy { - no_copy(const no_copy&) {} -public: - no_copy() {}; -}; - -no_copy y; - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -tuple x = tuple(y); // ok -#endif -#ifdef E1 -tuple v1; // should faild -#endif - -char cs[10]; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) -tuple v2(cs); // ok -#endif -#ifdef E2 -tuple v3; // should fail, arrays must be stored as references -#endif - - -// -tuple construction tests ------------------------------------ - -// a class without a public default constructor -class no_def_constructor { - no_def_constructor() {} -public: - no_def_constructor(std::string) {} // can be constructed with a string - }; - - -void foo1() { - -#ifdef E3 - dummy(tuple()); - // should fail - -#endif - dummy( tuple( - std::string("Jaba"), // ok, since the default - std::string("Daba"), // constructor is not used - std::string("Doo"))); -} - -void foo2() { -// testing default values - dummy(tuple()); - dummy(tuple(1)); - dummy(tuple(1,3.14)); - -#ifdef E4 - dummy(tuple()); // should fail, not defaults for references - dummy(tuple()); // likewise -#endif - - double dd = 5; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - dummy(tuple(dd)); // ok -#endif - -#ifdef E5 - dummy(tuple(dd+3.14)); // should fail, temporary to non-const reference -#endif -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - dummy(tuple(dd+3.14)); // ok, but potentially dangerous -#endif -} - - - -// make_tuple ------------------------------------------ - - - void foo3() { -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - 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(ref(ca)); -#endif - - -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - make_tuple("Donald", "Daisy"); // should work; -#endif -#ifdef E7 - std::make_pair("Doesn't","Work"); // fails -#endif -// You can store a reference to a function in a tuple -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - tuple adf(foo3); - - 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 - -// make_tuple(foo3); - -// With function pointers, make_tuple works just fine - -#if !defined(__BORLANDC__) || __BORLAND__ > 0x0551 - make_tuple(&foo3); -#endif - - - - -// NOTE: -// -// wrapping it the function reference with ref helps on gcc 2.95.2. -// on edg 2.43. it results in a catastrophic error? - -// make_tuple(ref(foo3)); - -// It seems that edg can't use implicitly the ref's conversion operator, e.g.: -// typedef void (&foo3type) (void); -// foo3type foo3ref = static_cast(ref(foo3)); // works fine -// foo3type foo3ref = ref(foo3); // error - -// This is probably not a very common situation, so currently -// I don't know how which compiler is right (JJ) - -} - - - -// - testing element access - -void foo4() -{ -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - double d = 2.7; - A a; - tuple t(1, d, a); - const tuple ct = t; - - int i = get<0>(t); - int j = get<0>(ct); - BOOST_TEST(i == 1 && j == 1); - - get<0>(t) = 5; - BOOST_TEST(t.head == 5); - -#ifdef E8 - get<0>(ct) = 5; // can't assign to const -#endif - - 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); - -#ifdef E9 - get<4>(t) = A(); // can't assign to const -#endif -#ifdef E10 - dummy(get<5>(ct)); // illegal index -#endif - - ++get<0>(t); - BOOST_TEST(get<0>(t) == 6); - - dummy(i); dummy(j); dummy(e); // avoid warns for unused variables -#endif -} - -// testing copy and assignment with implicit conversions between elements -// testing tie - - class AA {}; - class BB : public AA {}; - struct CC { CC() {} CC(const BB& b) {} }; - struct DD { operator CC() const { return CC(); }; }; - - void foo5() { - tuple t; - tuple a(t); - a = t; - } - - void foo6() { - int i; char c; double d; - tie(i, c, d) = make_tuple(1, 'a', 5.5); - BOOST_TEST(i==1); - BOOST_TEST(c=='a'); - BOOST_TEST(d==5.5); - } - -// testing tie -// testing assignment from std::pair -void foo7() { -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - int i, j; - tie (i, j) = std::make_pair(1, 2); - BOOST_TEST(i == 1 && j == 2); -#endif - tuple a; -#ifdef E11 - a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2 -#endif - -// the result of make_tuple is assignable: - BOOST_TEST(make_tuple(2, 4, 6) == - (make_tuple(1, 2, 3) = make_tuple(2, 4, 6))); - - dummy(a); -} - -// Testing cons lists -void foo8() -{ - cons a(1, null_type()); - cons > b(2,a); - int i = 3; - cons > > c(i, b); - BOOST_TEST(make_tuple(3,2,1)==c); -} - - -// -------------------------------- -// ---------------------------- -int test_main(int, char *[]) { - - foo1(); - foo2(); - foo3(); - foo4(); - foo5(); - foo6(); - foo7(); - foo8(); - - return 0; -}