Join ralf_grosse_kunstleve with HEAD

[SVN r9444]

compressed_pair_test.cpp

@@ -0,0 +1,154 @@
+ // boost::compressed_pair test program   
+    
+ //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
+ //  distribute this software is granted provided this copyright notice appears   
+ //  in all copies. This software is provided "as is" without express or implied   
+ //  warranty, and with no claim as to its suitability for any purpose.   
+
+// standalone test program for <boost/compressed_pair.hpp>
+// Revised 03 Oct 2000: 
+//    Enabled tests for VC6.
+
+#include <iostream>
+#include <typeinfo>
+#include <cassert>
+
+#include <boost/compressed_pair.hpp>
+#include <boost/type_traits/type_traits_test.hpp>
+
+using namespace boost;
+
+namespace boost {
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+template <> struct is_empty<empty_UDT>
+{ static const bool value = true; };
+template <> struct is_empty<empty_POD_UDT>
+{ static const bool value = true; };
+template <> struct is_POD<empty_POD_UDT>
+{ static const bool value = true; };
+#else
+template <> struct is_empty<empty_UDT>
+{ enum{ value = true }; };
+template <> struct is_empty<empty_POD_UDT>
+{ enum{ value = true }; };
+template <> struct is_POD<empty_POD_UDT>
+{ enum{ value = true }; };
+#endif
+}
+
+struct non_empty1
+{ 
+   int i;
+   non_empty1() : i(1){}
+   non_empty1(int v) : i(v){}
+   friend bool operator==(const non_empty1& a, const non_empty1& b)
+   { return a.i == b.i; }
+};
+
+struct non_empty2
+{ 
+   int i;
+   non_empty2() : i(3){}
+   non_empty2(int v) : i(v){}
+   friend bool operator==(const non_empty2& a, const non_empty2& b)
+   { return a.i == b.i; }
+};
+
+int main(int argc, char *argv[ ])
+{
+   compressed_pair<int, double> cp1(1, 1.3);
+   assert(cp1.first() == 1);
+   assert(cp1.second() == 1.3);
+   compressed_pair<int, double> cp1b(2, 2.3);
+   assert(cp1b.first() == 2);
+   assert(cp1b.second() == 2.3);
+   swap(cp1, cp1b);
+   assert(cp1b.first() == 1);
+   assert(cp1b.second() == 1.3);
+   assert(cp1.first() == 2);
+   assert(cp1.second() == 2.3);
+   compressed_pair<non_empty1, non_empty2> cp1c(non_empty1(9));
+   assert(cp1c.second() == non_empty2());
+   assert(cp1c.first() == non_empty1(9));
+   compressed_pair<non_empty1, non_empty2> cp1d(non_empty2(9));
+   assert(cp1d.second() == non_empty2(9));
+   assert(cp1d.first() == non_empty1());
+
+   compressed_pair<int, double> cp1e(cp1);
+
+   compressed_pair<empty_UDT, int> cp2(2);
+   assert(cp2.second() == 2);
+   compressed_pair<int, empty_UDT> cp3(1);
+   assert(cp3.first() ==1);
+   compressed_pair<empty_UDT, empty_UDT> cp4;
+   compressed_pair<empty_UDT, empty_POD_UDT> cp5;
+   compressed_pair<int, empty_UDT> cp9(empty_UDT());
+   compressed_pair<int, empty_UDT> cp10(1);
+   assert(cp10.first() == 1);
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+   int i = 0;
+   compressed_pair<int&, int&> cp6(i,i);
+   assert(cp6.first() == i);
+   assert(cp6.second() == i);
+   assert(&cp6.first() == &i);
+   assert(&cp6.second() == &i);
+   compressed_pair<int, double[2]> cp7;
+   cp7.first();
+   double* pd = cp7.second();
+#endif
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, int>) < sizeof(std::pair<empty_UDT, int>)))
+   soft_value_test(true, (sizeof(compressed_pair<int, empty_UDT>) < sizeof(std::pair<int, empty_UDT>)))
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, empty_UDT>) < sizeof(std::pair<empty_UDT, empty_UDT>)))
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, empty_POD_UDT>) < sizeof(std::pair<empty_UDT, empty_POD_UDT>)))
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, compressed_pair<empty_POD_UDT, int> >) < sizeof(std::pair<empty_UDT, std::pair<empty_POD_UDT, int> >)))
+
+   return check_result(argc, argv);
+}
+
+//
+// instanciate some compressed pairs:
+#ifdef __MWERKS__
+template class compressed_pair<int, double>;
+template class compressed_pair<int, int>;
+template class compressed_pair<empty_UDT, int>;
+template class compressed_pair<int, empty_UDT>;
+template class compressed_pair<empty_UDT, empty_UDT>;
+template class compressed_pair<empty_UDT, empty_POD_UDT>;
+#else
+template class boost::compressed_pair<int, double>;
+template class boost::compressed_pair<int, int>;
+template class boost::compressed_pair<empty_UDT, int>;
+template class boost::compressed_pair<int, empty_UDT>;
+template class boost::compressed_pair<empty_UDT, empty_UDT>;
+template class boost::compressed_pair<empty_UDT, empty_POD_UDT>;
+#endif
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#ifndef __MWERKS__
+//
+// now some for which only a few specific members can be instantiated,
+// first references:
+template double& compressed_pair<double, int&>::first();
+template int& compressed_pair<double, int&>::second();
+#if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 95))
+template compressed_pair<double, int&>::compressed_pair(int&);
+#endif
+template compressed_pair<double, int&>::compressed_pair(call_traits<double>::param_type,int&);
+//
+// and then arrays:
+#ifndef __BORLANDC__
+template call_traits<int[2]>::reference compressed_pair<double, int[2]>::second();
+#endif
+template call_traits<double>::reference compressed_pair<double, int[2]>::first();
+#if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 95))
+template compressed_pair<double, int[2]>::compressed_pair(call_traits<double>::param_type);
+#endif
+template compressed_pair<double, int[2]>::compressed_pair();
+#endif // __MWERKS__
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+unsigned int expected_failures = 0;
+
+
+
+

counting_iterator_test.cpp

@@ -1,263 +0,0 @@
-// (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-// distribute this software is granted provided this copyright notice appears in
-// all copies. This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//  See http://www.boost.org for most recent version including documentation.
-//
-// Revision History
-// 16 Feb 2001  Added a missing const. Made the tests run (somewhat) with
-//              plain MSVC again. (David Abrahams)
-// 11 Feb 2001  #if 0'd out use of counting_iterator on non-numeric types in
-//              MSVC without STLport, so that the other tests may proceed
-//              (David Abrahams)
-// 04 Feb 2001  Added use of iterator_tests.hpp (David Abrahams)
-// 28 Jan 2001  Removed not_an_iterator detritus (David Abrahams)
-// 24 Jan 2001  Initial revision (David Abrahams)
-
-#include <boost/config.hpp>
-#ifdef BOOST_MSVC
-# pragma warning(disable:4786) // identifier truncated in debug info
-#endif
-
-#include <boost/pending/iterator_tests.hpp>
-#include <boost/counting_iterator.hpp>
-#include <boost/detail/iterator.hpp>
-#include <iostream>
-#include <climits>
-#include <iterator>
-#include <stdlib.h>
-#include <boost/utility.hpp>
-#include <vector>
-#include <list>
-#include <cassert>
-#ifndef BOOST_NO_LIMITS
-# include <limits>
-#endif
-#ifndef BOOST_NO_SLIST
-# include <slist>
-#endif
-
-template <class T> struct is_numeric
-{
-    enum { value = 
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-        std::numeric_limits<T>::is_specialized
-#else
-        // Causes warnings with GCC, but how else can I detect numeric types at
-        // compile-time?
-        (boost::is_convertible<int,T>::value &&
-         boost::is_convertible<T,int>::value)
-#endif
-    };
-};
-
-// Special tests for RandomAccess CountingIterators.
-template <class CountingIterator>
-void category_test(
-    CountingIterator start,
-    CountingIterator finish,
-    std::random_access_iterator_tag)
-{
-    typedef typename
-        boost::detail::iterator_traits<CountingIterator>::difference_type
-        difference_type;
-    difference_type distance = boost::detail::distance(start, finish);
-
-    // Pick a random position internal to the range
-    difference_type offset = (unsigned)rand() % distance;
-    assert(offset >= 0);
-    CountingIterator internal = start;
-    std::advance(internal, offset);
-
-    // Try some binary searches on the range to show that it's ordered
-    assert(std::binary_search(start, finish, *internal));
-    CountingIterator x,y;
-    boost::tie(x,y) = std::equal_range(start, finish, *internal);
-    assert(boost::detail::distance(x, y) == 1);
-
-    // Show that values outside the range can't be found
-    assert(!std::binary_search(start, boost::prior(finish), *finish));
-
-    // Do the generic random_access_iterator_test
-    typedef typename CountingIterator::value_type value_type;
-    std::vector<value_type> v;
-    for (value_type z = *start; z != *finish; ++z)
-        v.push_back(z);
-    if (v.size() >= 2)
-    {
-        // Note that this test requires a that the first argument is
-        // dereferenceable /and/ a valid iterator prior to the first argument
-        boost::random_access_iterator_test(start + 1, v.size() - 1, v.begin() + 1);
-    }
-}
-
-// Special tests for bidirectional CountingIterators
-template <class CountingIterator>
-void category_test(CountingIterator start, CountingIterator finish, std::bidirectional_iterator_tag)
-{
-    if (finish != start
-        && finish != boost::next(start)
-        && finish != boost::next(boost::next(start)))
-    {
-        // Note that this test requires a that the first argument is
-        // dereferenceable /and/ a valid iterator prior to the first argument
-        boost::bidirectional_iterator_test(boost::next(start), boost::next(*start), boost::next(boost::next(*start)));
-    }
-}
-
-template <class CountingIterator>
-void category_test(CountingIterator start, CountingIterator finish, std::forward_iterator_tag)
-{
-    if (finish != start && finish != boost::next(start))
-        boost::forward_iterator_test(start, *start, boost::next(*start));
-}
-
-template <class CountingIterator>
-void test_aux(CountingIterator start, CountingIterator finish)
-{
-    typedef typename CountingIterator::iterator_category category;
-    typedef typename CountingIterator::value_type value_type;
-
-    // If it's a RandomAccessIterator we can do a few delicate tests
-    category_test(start, finish, category());
-    
-    // Okay, brute force...
-    for (CountingIterator p = start; p != finish && boost::next(p) != finish; ++p)
-    {
-        assert(boost::next(*p) == *boost::next(p));
-    }
-
-    // prove that a reference can be formed to these values
-    typedef typename CountingIterator::value_type value;
-    const value* q = &*start;
-    (void)q; // suppress unused variable warning
-}
-
-template <class Incrementable>
-void test(Incrementable start, Incrementable finish)
-{
-    test_aux(boost::make_counting_iterator(start), boost::make_counting_iterator(finish));
-}
-
-template <class Integer>
-void test_integer(Integer* = 0) // default arg works around MSVC bug
-{
-    Integer start = 0;
-    Integer finish = 120;
-    test(start, finish);
-}
-
-template <class Container>
-void test_container(Container* = 0)  // default arg works around MSVC bug
-{
-    Container c(1 + (unsigned)rand() % 1673);
-
-    const typename Container::iterator start = c.begin();
-    
-    // back off by 1 to leave room for dereferenceable value at the end
-    typename Container::iterator finish = start;
-    std::advance(finish, c.size() - 1);
-    
-    test(start, finish);
-
-    typedef typename Container::const_iterator const_iterator;
-    test(const_iterator(start), const_iterator(finish));
-}
-
-class my_int1 {
-public:
-  my_int1() { }
-  my_int1(int x) : m_int(x) { }
-  my_int1& operator++() { ++m_int; return *this; }
-  bool operator==(const my_int1& x) const { return m_int == x.m_int; }
-private:
-  int m_int;
-};
-
-namespace boost {
-  template <>
-  struct counting_iterator_traits<my_int1> {
-    typedef std::ptrdiff_t difference_type;
-    typedef std::forward_iterator_tag iterator_category;
-  };
-}
-
-class my_int2 {
-public:
-  typedef void value_type;
-  typedef void pointer;
-  typedef void reference;
-  typedef std::ptrdiff_t difference_type;
-  typedef std::bidirectional_iterator_tag iterator_category;
-
-  my_int2() { }
-  my_int2(int x) : m_int(x) { }
-  my_int2& operator++() { ++m_int; return *this; }
-  my_int2& operator--() { --m_int; return *this; }
-  bool operator==(const my_int2& x) const { return m_int == x.m_int; }
-private:
-  int m_int;
-};
-
-class my_int3 {
-public:
-  typedef void value_type;
-  typedef void pointer;
-  typedef void reference;
-  typedef std::ptrdiff_t difference_type;
-  typedef std::random_access_iterator_tag iterator_category;
-
-  my_int3() { }
-  my_int3(int x) : m_int(x) { }
-  my_int3& operator++() { ++m_int; return *this; }
-  my_int3& operator+=(std::ptrdiff_t n) { m_int += n; return *this; }
-  std::ptrdiff_t operator-(const my_int3& x) const { return m_int - x.m_int; }
-  my_int3& operator--() { --m_int; return *this; }
-  bool operator==(const my_int3& x) const { return m_int == x.m_int; }
-  bool operator!=(const my_int3& x) const { return m_int != x.m_int; }
-  bool operator<(const my_int3& x) const { return m_int < x.m_int; }
-private:
-  int m_int;
-};
-
-int main()
-{
-    // Test the built-in integer types.
-    test_integer<char>();
-    test_integer<unsigned char>();
-    test_integer<signed char>();
-    test_integer<wchar_t>();
-    test_integer<short>();
-    test_integer<unsigned short>();
-    test_integer<int>();
-    test_integer<unsigned int>();
-    test_integer<long>();
-    test_integer<unsigned long>();
-#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
-    test_integer<long long>();
-    test_integer<unsigned long long>();
-#endif
-
-   // wrapping an iterator or non-built-in integer type causes an INTERNAL
-   // COMPILER ERROR in MSVC without STLport. I'm clueless as to why.
-#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
-    // Test user-defined type.
-    test_integer<my_int1>();
-    test_integer<my_int2>();
-    test_integer<my_int3>();
-    
-   // Some tests on container iterators, to prove we handle a few different categories
-    test_container<std::vector<int> >();
-    test_container<std::list<int> >();
-# ifndef BOOST_NO_SLIST
-    test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
-# endif
-    
-    // Also prove that we can handle raw pointers.
-    int array[2000];
-    test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
-#endif
-    std::cout << "test successful " << std::endl;
-    return 0;
-}

fun_out_iter_example.cpp

@@ -1,41 +0,0 @@
-// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-// Revision History:
-
-// 27 Feb 2001   Jeremy Siek
-//      Initial checkin.
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <boost/function_output_iterator.hpp>
-
-struct string_appender {
-  string_appender(std::string& s) : m_str(s) { }
-  void operator()(const std::string& x) const {
-    m_str += x;
-  }
-  std::string& m_str;
-};
-
-int main(int, char*[])
-{
-  std::vector<std::string> x;
-  x.push_back("hello");
-  x.push_back(" ");
-  x.push_back("world");
-  x.push_back("!");
-
-  std::string s = "";
-  std::copy(x.begin(), x.end(), 
-	    boost::make_function_output_iterator(string_appender(s)));
-  
-  std::cout << s << std::endl;
-
-  return 0;
-}

function_output_iterator.htm

@@ -1,169 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-
-<html>
-<head>
-    <meta name="generator" content="HTML Tidy, see www.w3.org">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-    <meta name="ProgId" content="FrontPage.Editor.Document">
-
-    <title>Function Output Iterator Adaptor Documentation</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-        
-    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
-    "center" width="277" height="86"> 
-
-    <h1>Function Output Iterator Adaptor</h1>
-    Defined in header <a href=
-    "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a> 
-
-    <p>The function output iterator adaptor makes it easier to create
-    custom output iterators. The adaptor takes a <a
-    href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
-    Function</a> and creates a model of <a
-    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
-    Iterator</a>. Each item assigned to the output iterator is passed
-    as an argument to the unary function.  The motivation for this
-    iterator is that creating a C++ Standard conforming output
-    iterator is non-trivial, particularly because the proper
-    implementation usually requires a proxy object. On the other hand,
-    creating a function (or function object) is much simpler.
-
-    <h2>Synopsis</h2>
-
-    <blockquote>
-<pre>
-namespace boost {
-  template &lt;class UnaryFunction&gt;
-  class function_output_iterator;
-
-  template &lt;class UnaryFunction&gt;
-  function_output_iterator&lt;UnaryFunction&gt;
-  make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
-}
-</pre>
-    </blockquote>
-
-    <h3>Example</h3>
-    
-    In this example we create an output iterator that appends
-    each item onto the end of a string, using the <tt>string_appender</tt>
-    function. 
-
-    <blockquote>
-<pre>
-#include &lt;iostream&gt;
-#include &lt;string&gt;
-#include &lt;vector&gt;
-
-#include &lt;boost/function_output_iterator.hpp&gt;
-
-struct string_appender {
-  string_appender(std::string&amp; s) : m_str(s) { }
-  void operator()(const std::string&amp; x) const {
-    m_str += x;
-  }
-  std::string&amp; m_str;
-};
-
-int main(int, char*[])
-{
-  std::vector&lt;std::string&gt; x;
-  x.push_back("hello");
-  x.push_back(" ");
-  x.push_back("world");
-  x.push_back("!");
-
-  std::string s = "";
-  std::copy(x.begin(), x.end(), 
-            boost::make_function_output_iterator(string_appender(s)));
-  
-  std::cout &lt;&lt; s &lt;&lt; std::endl;
-
-  return 0;
-}
-</pre>
-    </blockquote>
-
-    <hr>
-
-    <h2><a name="function_output_iterator">The Function Output Iterator Class</a></h2>
-
-    <blockquote>
-<pre>
-template &lt;class UnaryFunction&gt;
-class function_output_iterator;
-</pre>
-    </blockquote>
-
-    The <tt>function_output_iterator</tt> class creates an <a
-    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
-    Iterator</a> out of a
-    <a href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
-    Function</a>. Each item assigned to the output iterator is passed
-    as an argument to the unary function.
-
-    <h3>Template Parameters</h3>
-
-    <table border>
-      <tr>
-        <th>Parameter
-
-        <th>Description
-
-      <tr>
-        <td><tt>UnaryFunction</tt> 
-
-        <td>The function type being wrapped. The return type of the
-        function is not used, so it can be <tt>void</tt>.  The
-        function must be a model of <a
-        href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
-        Function</a>.</td>
-    </table>
-
-    <h3>Concept Model</h3>
-    The function output iterator class is a model of <a
-    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
-    Iterator</a>.
-
-    <h2>Members</h3>
-    The function output iterator implements the member functions
-    and operators required of the <a
-    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
-    Iterator</a> concept. In addition it has the following constructor:
-<pre>
-explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
-</pre>
-   <br>    
-    <br>
-
-    <hr>
-    <h2><a name="make_function_output_iterator">The Function Output Iterator Object
-    Generator</a></h2>
-
-    The <tt>make_function_output_iterator()</tt> function provides a
-    more convenient way to create function output iterator objects. The
-    function saves the user the trouble of explicitly writing out the
-    iterator types. If the default argument is used, the function
-    type must be provided as an explicit template argument.
-
-    <blockquote>
-<pre>
-template &lt;class UnaryFunction&gt;
-function_output_iterator&lt;UnaryFunction&gt;
-make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
-</pre>
-    </blockquote>
-
-    <hr>
-
-    <p>&copy; Copyright Jeremy Siek 2001. Permission to copy, use,
-    modify, sell and distribute this document is granted provided this
-    copyright notice appears in all copies. This document is provided
-    "as is" without express or implied warranty, and with no claim as
-    to its suitability for any purpose.
-
-</body>
-</html>

include/boost/detail/ob_compressed_pair.hpp

@@ -0,0 +1,509 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+//  see libs/utility/compressed_pair.hpp
+//
+/* Release notes:
+   20 Jan 2001:
+        Fixed obvious bugs (David Abrahams)
+	07 Oct 2000:
+		Added better single argument constructor support.
+   03 Oct 2000:
+      Added VC6 support (JM).
+   23rd July 2000:
+      Additional comments added. (JM)
+   Jan 2000:
+      Original version: this version crippled for use with crippled compilers
+      - John Maddock Jan 2000.
+*/
+
+
+#ifndef BOOST_OB_COMPRESSED_PAIR_HPP
+#define BOOST_OB_COMPRESSED_PAIR_HPP
+
+#include <algorithm>
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
+#include <boost/type_traits/object_traits.hpp>
+#endif
+#ifndef BOOST_SAME_TRAITS_HPP
+#include <boost/type_traits/same_traits.hpp>
+#endif
+#ifndef BOOST_CALL_TRAITS_HPP
+#include <boost/call_traits.hpp>
+#endif
+
+namespace boost
+{
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
+//
+// use member templates to emulate
+// partial specialisation.  Note that due to
+// problems with overload resolution with VC6
+// each of the compressed_pair versions that follow
+// have one template single-argument constructor
+// in place of two specific constructors:
+//
+
+template <class T1, class T2>
+class compressed_pair;
+
+namespace detail{
+
+template <class A, class T1, class T2>
+struct best_conversion_traits
+{
+   typedef char one;
+   typedef char (&two)[2];
+   static A a;
+   static one test(T1);
+   static two test(T2);
+
+   enum { value = sizeof(test(a)) };
+};
+
+template <int>
+struct init_one;
+
+template <>
+struct init_one<1>
+{
+   template <class A, class T1, class T2>
+   static void init(const A& a, T1* p1, T2*)
+   {
+      *p1 = a;
+   }
+};
+
+template <>
+struct init_one<2>
+{
+   template <class A, class T1, class T2>
+   static void init(const A& a, T1*, T2* p2)
+   {
+      *p2 = a;
+   }
+};
+
+
+// T1 != T2, both non-empty
+template <class T1, class T2>
+class compressed_pair_0
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_0() : _first(), _second() {}
+            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   template <class A>
+   explicit compressed_pair_0(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
+   }
+   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
+      : _first(x.first()), _second(x.second()) {}
+
+#if 0
+  compressed_pair_0& operator=(const compressed_pair_0& x) {
+    cout << "assigning compressed pair 0" << endl;
+    _first = x._first;
+    _second = x._second;
+    cout << "finished assigning compressed pair 0" << endl;
+    return *this;
+  }
+#endif
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_0& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+// T1 != T2, T2 empty
+template <class T1, class T2>
+class compressed_pair_1 : T2
+{
+private:
+   T1 _first;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_1() : T2(), _first() {}
+            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
+
+   template <class A>
+   explicit compressed_pair_1(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
+   }
+
+   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
+      : T2(x.second()), _first(x.first()) {}
+
+#ifdef BOOST_MSVC
+  // Total weirdness. If the assignment to _first is moved after
+  // the call to the inherited operator=, then this breaks graph/test/graph.cpp
+  // by way of iterator_adaptor.
+  compressed_pair_1& operator=(const compressed_pair_1& x) {
+    _first = x._first;
+    T2::operator=(x);
+    return *this;
+  }
+#endif
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_1& y)
+   {
+      // no need to swap empty base class:
+      using std::swap;
+      swap(_first, y._first);
+   }
+};
+
+// T1 != T2, T1 empty
+template <class T1, class T2>
+class compressed_pair_2 : T1
+{
+private:
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_2() : T1(), _second() {}
+            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
+   template <class A>
+   explicit compressed_pair_2(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
+   }
+   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), _second(x.second()) {}
+
+#if 0
+  compressed_pair_2& operator=(const compressed_pair_2& x) {
+    cout << "assigning compressed pair 2" << endl;
+    T1::operator=(x);
+    _second = x._second;
+    cout << "finished assigning compressed pair 2" << endl;
+    return *this;
+  }
+#endif
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_2& y)
+   {
+      // no need to swap empty base class:
+      using std::swap;
+      swap(_second, y._second);
+   }
+};
+
+// T1 != T2, both empty
+template <class T1, class T2>
+class compressed_pair_3 : T1, T2
+{
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_3() : T1(), T2() {}
+            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
+   template <class A>
+   explicit compressed_pair_3(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
+   }
+   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), T2(x.second()) {}
+
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_3& y)
+   {
+      // no need to swap empty base classes:
+   }
+};
+
+// T1 == T2, and empty
+template <class T1, class T2>
+class compressed_pair_4 : T1
+{
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_4() : T1() {}
+            compressed_pair_4(first_param_type x, second_param_type) : T1(x) {}
+   // only one single argument constructor since T1 == T2
+   explicit compressed_pair_4(first_param_type x) : T1(x) {}
+   compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()){}
+
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_4& y)
+   {
+      // no need to swap empty base classes:
+   }
+};
+
+// T1 == T2, not empty
+template <class T1, class T2>
+class compressed_pair_5
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_5() : _first(), _second() {}
+            compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   // only one single argument constructor since T1 == T2
+   explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
+   compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) 
+      : _first(c.first()), _second(c.second()) {}
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_5& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+template <bool e1, bool e2, bool same>
+struct compressed_pair_chooser
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_0<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<false, true, false>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_1<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<true, false, false>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_2<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<true, true, false>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_3<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<true, true, true>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_4<T1, T2> type;
+   };
+};
+
+template <>
+struct compressed_pair_chooser<false, false, true>
+{
+   template <class T1, class T2>
+   struct rebind
+   {
+      typedef compressed_pair_5<T1, T2> type;
+   };
+};
+
+template <class T1, class T2>
+struct compressed_pair_traits
+{
+private:
+   typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
+   typedef typename chooser::template rebind<T1, T2> bound_type;
+public:
+   typedef typename bound_type::type type;
+};
+
+} // namespace detail
+
+template <class T1, class T2>
+class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
+{
+private:
+   typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : base_type() {}
+            compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
+   template <class A>
+   explicit compressed_pair(const A& x) : base_type(x){}
+
+   first_reference       first()       { return base_type::first(); }
+   first_const_reference first() const { return base_type::first(); }
+
+   second_reference       second()       { return base_type::second(); }
+   second_const_reference second() const { return base_type::second(); }
+};
+
+template <class T1, class T2>
+inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+   x.swap(y);
+}
+
+#else
+// no partial specialisation, no member templates:
+
+template <class T1, class T2>
+class compressed_pair
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : _first(), _second() {}
+            compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   explicit compressed_pair(first_param_type x) : _first(x), _second() {}
+   // can't define this in case T1 == T2:
+   // explicit compressed_pair(second_param_type y) : _first(), _second(y) {}
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+template <class T1, class T2>
+inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+   x.swap(y);
+}
+
+#endif
+
+} // boost
+
+#endif // BOOST_OB_COMPRESSED_PAIR_HPP
+
+
+

iter_adaptor_fail_expected1.cpp

@@ -1,27 +0,0 @@
-//  Test boost/pending/iterator_adaptors.hpp
-
-//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
-//  sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-// Revision History
-// 21 Jan 01 Initial version (Jeremy Siek)
-
-#include <boost/config.hpp>
-#include <list>
-#include <boost/pending/iterator_adaptors.hpp>
-
-int main()
-{
-  typedef boost::iterator_adaptor<std::list<int>::iterator,
-    boost::default_iterator_policies,
-    int,int&,int*,std::bidirectional_iterator_tag> adaptor_type;
-  
-  adaptor_type i;
-  i += 4;
-  return 0;
-}

iter_adaptor_fail_expected2.cpp

@@ -1,28 +0,0 @@
-//  Test boost/pending/iterator_adaptors.hpp
-
-//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
-//  sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-// Revision History
-// 21 Jan 01 Initial version (Jeremy Siek)
-
-#include <boost/config.hpp>
-#include <iostream>
-#include <iterator>
-#include <boost/pending/iterator_adaptors.hpp>
-
-int main()
-{
-  typedef boost::iterator_adaptor<std::istream_iterator<int>,
-    boost::default_iterator_policies,
-    int,int&,int*,std::input_iterator_tag> adaptor_type;
-  
-  adaptor_type iter;
-  --iter;
-  return 0;
-}

projection_iterator_example.cpp

@@ -1,96 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
-// distribute this software is granted provided this copyright notice appears
-// in all copies. This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/config.hpp>
-#include <list>
-#include <iostream>
-#include <iterator>
-#include <algorithm>
-#include <string>
-#include <boost/iterator_adaptors.hpp>
-
-struct personnel_record {
-  personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
-  std::string m_name;
-  int m_ID;
-};
-
-struct select_name {
-  typedef personnel_record argument_type;
-  typedef std::string result_type;
-  const std::string& operator()(const personnel_record& r) const {
-    return r.m_name;
-  }
-  std::string& operator()(personnel_record& r) const {
-    return r.m_name;
-  }
-};
-
-struct select_ID {
-  typedef personnel_record argument_type;
-  typedef int result_type;
-  const int& operator()(const personnel_record& r) const {
-    return r.m_ID;
-  }
-  int& operator()(personnel_record& r) const {
-    return r.m_ID;
-  }
-};
-
-int main(int, char*[])
-{
-  std::list<personnel_record> personnel_list;
-
-  personnel_list.push_back(personnel_record("Barney", 13423));
-  personnel_list.push_back(personnel_record("Fred", 12343));
-  personnel_list.push_back(personnel_record("Wilma", 62454));
-  personnel_list.push_back(personnel_record("Betty", 20490));
-
-  // Example of using projection_iterator_generator
-  // to print out the names in the personnel list.
-
-  boost::projection_iterator_generator<select_name,
-    std::list<personnel_record>::iterator>::type
-    personnel_first(personnel_list.begin()),
-    personnel_last(personnel_list.end());
-
-  std::copy(personnel_first, personnel_last,
-            std::ostream_iterator<std::string>(std::cout, "\n"));
-  std::cout << std::endl;
-  
-  // Example of using projection_iterator_pair_generator
-  // to assign new ID numbers to the personnel.
-  
-  typedef boost::projection_iterator_pair_generator<select_ID,
-    std::list<personnel_record>::iterator,
-    std::list<personnel_record>::const_iterator> PairGen;
-
-  PairGen::iterator ID_first(personnel_list.begin()),
-    ID_last(personnel_list.end());
-
-  int new_id = 0;
-  while (ID_first != ID_last) {
-    *ID_first = new_id++;
-    ++ID_first;
-  }
-
-  PairGen::const_iterator const_ID_first(personnel_list.begin()),
-    const_ID_last(personnel_list.end());
-
-  std::copy(const_ID_first, const_ID_last,
-            std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-  std::cout << std::endl;
-  
-  // Example of using make_const_projection_iterator()
-  // to print out the names in the personnel list again.
-  
-  std::copy
-    (boost::make_const_projection_iterator<select_name>(personnel_list.begin()),
-     boost::make_const_projection_iterator<select_name>(personnel_list.end()),
-     std::ostream_iterator<std::string>(std::cout, "\n"));
-
-  return 0;
-}

reverse_iterator_example.cpp

@@ -1,42 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
-// distribute this software is granted provided this copyright notice appears
-// in all copies. This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-
-#include <boost/config.hpp>
-#include <iostream>
-#include <algorithm>
-#include <boost/iterator_adaptors.hpp>
-
-int main(int, char*[])
-{
-  char letters[] = "hello world!";
-  const int N = sizeof(letters)/sizeof(char) - 1;
-  std::cout << "original sequence of letters:\t"
-	    << letters << std::endl;
-
-  std::sort(letters, letters + N);
-
-  // Use reverse_iterator_generator to print a sequence
-  // of letters in reverse order.
-  
-  boost::reverse_iterator_generator<char*>::type
-    reverse_letters_first(letters + N),
-    reverse_letters_last(letters);
-
-  std::cout << "letters in descending order:\t";
-  std::copy(reverse_letters_first, reverse_letters_last,
-	    std::ostream_iterator<char>(std::cout));
-  std::cout << std::endl;
-
-  // Use make_reverse_iterator() to print the sequence
-  // of letters in reverse-reverse order.
-
-  std::cout << "letters in ascending order:\t";
-  std::copy(boost::make_reverse_iterator(reverse_letters_last),
-	    boost::make_reverse_iterator(reverse_letters_first),
-	    std::ostream_iterator<char>(std::cout));
-  std::cout << std::endl;
-
-  return 0;
-}

transform_iterator_example.cpp

@@ -1,44 +0,0 @@
-// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
-// distribute this software is granted provided this copyright notice appears
-// in all copies. This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-
-
-#include <functional>
-#include <algorithm>
-#include <iostream>
-#include <boost/iterator_adaptors.hpp>
-
-int
-main(int, char*[])
-{
-  // This is a simple example of using the transform_iterators class to
-  // generate iterators that multiply the value returned by dereferencing
-  // the iterator. In this case we are multiplying by 2.
-  // Would be cooler to use lambda library in this example.
-
-  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
-  const int N = sizeof(x)/sizeof(int);
-
-  typedef std::binder1st< std::multiplies<int> > Function;
-  typedef boost::transform_iterator_generator<Function, int*>::type doubling_iterator;
-
-  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
-    i_end(x + N, std::bind1st(std::multiplies<int>(), 2));
-
-  std::cout << "multiplying the array by 2:" << std::endl;
-  while (i != i_end)
-    std::cout << *i++ << " ";
-  std::cout << std::endl;
-
-  std::cout << "adding 4 to each element in the array:" << std::endl;
-
-  std::copy(boost::make_transform_iterator(x, std::bind1st(std::plus<int>(), 4)),
-	    boost::make_transform_iterator(x + N, std::bind1st(std::plus<int>(), 4)),
-	    std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-  
-  return 0;
-}
-
-